Figshare API

GET Account Article Report

{{baseUrl}}/account/articles/export

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/export");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/export")

require "http/client"

url = "{{baseUrl}}/account/articles/export"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/export"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/export");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/export"

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

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

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

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

}

GET /baseUrl/account/articles/export HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/export")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/export"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/export")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/export")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/export');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/articles/export'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/export';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/export',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/export")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/export',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/articles/export'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/export');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/articles/export'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/export';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/export"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/export" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/export",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/export');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/export');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/export');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/export' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/export' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/export")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/export"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/export"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/export")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/export') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/export";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/export

http GET {{baseUrl}}/account/articles/export

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/export

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "created_date": "2017-05-15T15:12:26Z",
    "download_url": "https://some.com/storage/path/123/report-456.xlsx"
  }
]

POST Add article authors

{{baseUrl}}/account/articles/:article_id/authors

BODY json

{
  "authors": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/authors");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/authors" {:content-type :json
                                                                                 :form-params {:authors [{:id 12121} {:id 34345} {:name "John Doe"}]}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/authors"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/authors"),
    Content = new StringContent("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/authors");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/authors"

	payload := strings.NewReader("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")

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

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

}

POST /baseUrl/account/articles/:article_id/authors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 121

{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/authors")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/authors"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/authors")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/authors');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/authors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/authors',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  headers: {'content-type': 'application/json'},
  body: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/authors');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/authors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{ @"id": @12121 }, @{ @"id": @34345 }, @{ @"name": @"John Doe" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/authors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/authors" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/authors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                'id' => 12121
        ],
        [
                'id' => 34345
        ],
        [
                'name' => 'John Doe'
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/authors', [
  'body' => '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/authors');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/authors');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/authors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/authors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles/:article_id/authors", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/authors"

payload = { "authors": [{ "id": 12121 }, { "id": 34345 }, { "name": "John Doe" }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/authors"

payload <- "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/authors")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles/:article_id/authors') do |req|
  req.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/authors";

    let payload = json!({"authors": (json!({"id": 12121}), json!({"id": 34345}), json!({"name": "John Doe"}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/authors \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

echo '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}' |  \
  http POST {{baseUrl}}/account/articles/:article_id/authors \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/authors

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["authors": [["id": 12121], ["id": 34345], ["name": "John Doe"]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/authors")! 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()

POST Add article categories

{{baseUrl}}/account/articles/:article_id/categories

BODY json

{
  "categories": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/categories" {:content-type :json
                                                                                    :form-params {:categories [1 10 11]}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/categories"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/categories"),
    Content = new StringContent("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/categories");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/categories"

	payload := strings.NewReader("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")

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

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

}

POST /baseUrl/account/articles/:article_id/categories HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "categories": [
    1,
    10,
    11
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/categories")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/categories"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/categories")
  .header("content-type", "application/json")
  .body("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .asString();

const data = JSON.stringify({
  categories: [
    1,
    10,
    11
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/categories');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/categories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/categories',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({categories: [1, 10, 11]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  headers: {'content-type': 'application/json'},
  body: {categories: [1, 10, 11]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/categories');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  categories: [
    1,
    10,
    11
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/categories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"categories": @[ @1, @10, @11 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/categories" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'categories' => [
        1,
        10,
        11
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/categories', [
  'body' => '{
  "categories": [
    1,
    10,
    11
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/categories');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/categories');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/categories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/categories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles/:article_id/categories", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/categories"

payload = { "categories": [1, 10, 11] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/categories"

payload <- "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/categories")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles/:article_id/categories') do |req|
  req.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/categories";

    let payload = json!({"categories": (1, 10, 11)});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/categories \
  --header 'content-type: application/json' \
  --data '{
  "categories": [
    1,
    10,
    11
  ]
}'

echo '{
  "categories": [
    1,
    10,
    11
  ]
}' |  \
  http POST {{baseUrl}}/account/articles/:article_id/categories \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/categories

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["categories": [1, 10, 11]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/categories")! 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()

GET Article Embargo Details

{{baseUrl}}/account/articles/:article_id/embargo

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/embargo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/embargo")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/embargo"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/embargo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/embargo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/embargo"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/embargo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/embargo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/embargo"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/embargo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/embargo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/embargo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/embargo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/embargo';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/embargo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/embargo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/embargo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/embargo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/embargo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/embargo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/embargo';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/embargo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/embargo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/embargo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/embargo');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/embargo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/embargo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/embargo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/embargo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/embargo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/embargo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/embargo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/embargo")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/embargo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/embargo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/embargo

http GET {{baseUrl}}/account/articles/:article_id/embargo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/embargo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/embargo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "group_ids": [],
      "id": 13,
      "ip_name": "bacau",
      "type": "ip_range"
    },
    {
      "group_ids": [
        550,
        9448
      ],
      "id": 12,
      "ip_name": "",
      "type": "logged_in"
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "",
  "is_embargoed": true
}

GET Article confidentiality details

{{baseUrl}}/account/articles/:article_id/confidentiality

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/confidentiality");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/confidentiality")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/confidentiality"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/confidentiality"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/confidentiality");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/confidentiality"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/confidentiality HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/confidentiality")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/confidentiality"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/confidentiality');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/confidentiality';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/confidentiality',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/confidentiality');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/confidentiality';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/confidentiality"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/confidentiality" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/confidentiality",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/confidentiality');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/confidentiality');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/confidentiality');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/confidentiality' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/confidentiality' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/confidentiality")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/confidentiality"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/confidentiality"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/confidentiality")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/confidentiality') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/confidentiality";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/confidentiality

http GET {{baseUrl}}/account/articles/:article_id/confidentiality

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/confidentiality

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/confidentiality")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "is_confidential": true,
  "reason": "need to"
}

GET Article details for version

{{baseUrl}}/articles/:article_id/versions/:v_number

QUERY PARAMS

article_id

v_number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id/versions/:v_number");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id/versions/:v_number")

require "http/client"

url = "{{baseUrl}}/articles/:article_id/versions/:v_number"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id/versions/:v_number"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id/versions/:v_number");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id/versions/:v_number"

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

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

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

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

}

GET /baseUrl/articles/:article_id/versions/:v_number HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id/versions/:v_number")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id/versions/:v_number"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions/:v_number")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id/versions/:v_number")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id/versions/:v_number';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions/:v_number")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id/versions/:v_number',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id/versions/:v_number';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id/versions/:v_number"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id/versions/:v_number" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id/versions/:v_number",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id/versions/:v_number');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id/versions/:v_number');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id/versions/:v_number' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id/versions/:v_number' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id/versions/:v_number")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id/versions/:v_number"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id/versions/:v_number"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id/versions/:v_number")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id/versions/:v_number') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id/versions/:v_number";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id/versions/:v_number

http GET {{baseUrl}}/articles/:article_id/versions/:v_number

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id/versions/:v_number

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id/versions/:v_number")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET Article details

{{baseUrl}}/account/articles/:article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/articles/:article_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/articles/:article_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/articles/:article_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id

http GET {{baseUrl}}/account/articles/:article_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "account_id": 1000001,
  "group_resource_id": null
}

GET Article file details

{{baseUrl}}/articles/:article_id/files/:file_id

QUERY PARAMS

article_id

file_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id/files/:file_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id/files/:file_id")

require "http/client"

url = "{{baseUrl}}/articles/:article_id/files/:file_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id/files/:file_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id/files/:file_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id/files/:file_id"

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

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

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

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

}

GET /baseUrl/articles/:article_id/files/:file_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id/files/:file_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id/files/:file_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/files/:file_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id/files/:file_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id/files/:file_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id/files/:file_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id/files/:file_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/files/:file_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id/files/:file_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/files/:file_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id/files/:file_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id/files/:file_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id/files/:file_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id/files/:file_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id/files/:file_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id/files/:file_id');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id/files/:file_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id/files/:file_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id/files/:file_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id/files/:file_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id/files/:file_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id/files/:file_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id/files/:file_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id/files/:file_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id/files/:file_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id/files/:file_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id/files/:file_id

http GET {{baseUrl}}/articles/:article_id/files/:file_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id/files/:file_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id/files/:file_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

POST Complete Upload

{{baseUrl}}/account/articles/:article_id/files/:file_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/files/:file_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/files/:file_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/files/:file_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/files/:file_id");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/files/:file_id"

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

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

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

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

}

POST /baseUrl/account/articles/:article_id/files/:file_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/files/:file_id"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/files/:file_id';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/files/:file_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/files/:file_id';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/files/:file_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/files/:file_id" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/files/:file_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/files/:file_id');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/files/:file_id');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/files/:file_id' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/files/:file_id' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/articles/:article_id/files/:file_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/files/:file_id")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/articles/:article_id/files/:file_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/files/:file_id";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/files/:file_id

http POST {{baseUrl}}/account/articles/:article_id/files/:file_id

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/files/:file_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/files/:file_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

POST Create new Article

{{baseUrl}}/account/articles

BODY json

{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles" {:content-type :json
                                                             :form-params {:authors [{}]
                                                                           :categories []
                                                                           :categories_by_source_id []
                                                                           :custom_fields {}
                                                                           :custom_fields_list [{:name ""
                                                                                                 :value ""}]
                                                                           :defined_type ""
                                                                           :description ""
                                                                           :doi ""
                                                                           :funding ""
                                                                           :funding_list [{:id 0
                                                                                           :title ""}]
                                                                           :group_id 0
                                                                           :handle ""
                                                                           :is_metadata_record false
                                                                           :keywords []
                                                                           :license 0
                                                                           :metadata_reason ""
                                                                           :references []
                                                                           :resource_doi ""
                                                                           :resource_title ""
                                                                           :tags []
                                                                           :timeline {:firstOnline ""
                                                                                      :publisherAcceptance ""
                                                                                      :publisherPublication ""}
                                                                           :title ""}})

require "http/client"

url = "{{baseUrl}}/account/articles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles"),
    Content = new StringContent("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles"

	payload := strings.NewReader("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")

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

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

}

POST /baseUrl/account/articles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 651

{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {}
  ],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  defined_type: '',
  description: '',
  doi: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  group_id: 0,
  handle: '',
  is_metadata_record: false,
  keywords: [],
  license: 0,
  metadata_reason: '',
  references: [],
  resource_doi: '',
  resource_title: '',
  tags: [],
  timeline: {
    firstOnline: '',
    publisherAcceptance: '',
    publisherPublication: ''
  },
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    defined_type: '',
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    handle: '',
    is_metadata_record: false,
    keywords: [],
    license: 0,
    metadata_reason: '',
    references: [],
    resource_doi: '',
    resource_title: '',
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{}],"categories":[],"categories_by_source_id":[],"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"defined_type":"","description":"","doi":"","funding":"","funding_list":[{"id":0,"title":""}],"group_id":0,"handle":"","is_metadata_record":false,"keywords":[],"license":0,"metadata_reason":"","references":[],"resource_doi":"","resource_title":"","tags":[],"timeline":{"firstOnline":"","publisherAcceptance":"","publisherPublication":""},"title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {}\n  ],\n  "categories": [],\n  "categories_by_source_id": [],\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "defined_type": "",\n  "description": "",\n  "doi": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "group_id": 0,\n  "handle": "",\n  "is_metadata_record": false,\n  "keywords": [],\n  "license": 0,\n  "metadata_reason": "",\n  "references": [],\n  "resource_doi": "",\n  "resource_title": "",\n  "tags": [],\n  "timeline": {\n    "firstOnline": "",\n    "publisherAcceptance": "",\n    "publisherPublication": ""\n  },\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  authors: [{}],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [{name: '', value: ''}],
  defined_type: '',
  description: '',
  doi: '',
  funding: '',
  funding_list: [{id: 0, title: ''}],
  group_id: 0,
  handle: '',
  is_metadata_record: false,
  keywords: [],
  license: 0,
  metadata_reason: '',
  references: [],
  resource_doi: '',
  resource_title: '',
  tags: [],
  timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles',
  headers: {'content-type': 'application/json'},
  body: {
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    defined_type: '',
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    handle: '',
    is_metadata_record: false,
    keywords: [],
    license: 0,
    metadata_reason: '',
    references: [],
    resource_doi: '',
    resource_title: '',
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {}
  ],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  defined_type: '',
  description: '',
  doi: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  group_id: 0,
  handle: '',
  is_metadata_record: false,
  keywords: [],
  license: 0,
  metadata_reason: '',
  references: [],
  resource_doi: '',
  resource_title: '',
  tags: [],
  timeline: {
    firstOnline: '',
    publisherAcceptance: '',
    publisherPublication: ''
  },
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    defined_type: '',
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    handle: '',
    is_metadata_record: false,
    keywords: [],
    license: 0,
    metadata_reason: '',
    references: [],
    resource_doi: '',
    resource_title: '',
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{}],"categories":[],"categories_by_source_id":[],"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"defined_type":"","description":"","doi":"","funding":"","funding_list":[{"id":0,"title":""}],"group_id":0,"handle":"","is_metadata_record":false,"keywords":[],"license":0,"metadata_reason":"","references":[],"resource_doi":"","resource_title":"","tags":[],"timeline":{"firstOnline":"","publisherAcceptance":"","publisherPublication":""},"title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{  } ],
                              @"categories": @[  ],
                              @"categories_by_source_id": @[  ],
                              @"custom_fields": @{  },
                              @"custom_fields_list": @[ @{ @"name": @"", @"value": @"" } ],
                              @"defined_type": @"",
                              @"description": @"",
                              @"doi": @"",
                              @"funding": @"",
                              @"funding_list": @[ @{ @"id": @0, @"title": @"" } ],
                              @"group_id": @0,
                              @"handle": @"",
                              @"is_metadata_record": @NO,
                              @"keywords": @[  ],
                              @"license": @0,
                              @"metadata_reason": @"",
                              @"references": @[  ],
                              @"resource_doi": @"",
                              @"resource_title": @"",
                              @"tags": @[  ],
                              @"timeline": @{ @"firstOnline": @"", @"publisherAcceptance": @"", @"publisherPublication": @"" },
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                
        ]
    ],
    'categories' => [
        
    ],
    'categories_by_source_id' => [
        
    ],
    'custom_fields' => [
        
    ],
    'custom_fields_list' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'defined_type' => '',
    'description' => '',
    'doi' => '',
    'funding' => '',
    'funding_list' => [
        [
                'id' => 0,
                'title' => ''
        ]
    ],
    'group_id' => 0,
    'handle' => '',
    'is_metadata_record' => null,
    'keywords' => [
        
    ],
    'license' => 0,
    'metadata_reason' => '',
    'references' => [
        
    ],
    'resource_doi' => '',
    'resource_title' => '',
    'tags' => [
        
    ],
    'timeline' => [
        'firstOnline' => '',
        'publisherAcceptance' => '',
        'publisherPublication' => ''
    ],
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles', [
  'body' => '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        
    ]
  ],
  'categories' => [
    
  ],
  'categories_by_source_id' => [
    
  ],
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'defined_type' => '',
  'description' => '',
  'doi' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'group_id' => 0,
  'handle' => '',
  'is_metadata_record' => null,
  'keywords' => [
    
  ],
  'license' => 0,
  'metadata_reason' => '',
  'references' => [
    
  ],
  'resource_doi' => '',
  'resource_title' => '',
  'tags' => [
    
  ],
  'timeline' => [
    'firstOnline' => '',
    'publisherAcceptance' => '',
    'publisherPublication' => ''
  ],
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        
    ]
  ],
  'categories' => [
    
  ],
  'categories_by_source_id' => [
    
  ],
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'defined_type' => '',
  'description' => '',
  'doi' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'group_id' => 0,
  'handle' => '',
  'is_metadata_record' => null,
  'keywords' => [
    
  ],
  'license' => 0,
  'metadata_reason' => '',
  'references' => [
    
  ],
  'resource_doi' => '',
  'resource_title' => '',
  'tags' => [
    
  ],
  'timeline' => [
    'firstOnline' => '',
    'publisherAcceptance' => '',
    'publisherPublication' => ''
  ],
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/articles');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles"

payload = {
    "authors": [{}],
    "categories": [],
    "categories_by_source_id": [],
    "custom_fields": {},
    "custom_fields_list": [
        {
            "name": "",
            "value": ""
        }
    ],
    "defined_type": "",
    "description": "",
    "doi": "",
    "funding": "",
    "funding_list": [
        {
            "id": 0,
            "title": ""
        }
    ],
    "group_id": 0,
    "handle": "",
    "is_metadata_record": False,
    "keywords": [],
    "license": 0,
    "metadata_reason": "",
    "references": [],
    "resource_doi": "",
    "resource_title": "",
    "tags": [],
    "timeline": {
        "firstOnline": "",
        "publisherAcceptance": "",
        "publisherPublication": ""
    },
    "title": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles"

payload <- "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles') do |req|
  req.body = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"is_metadata_record\": false,\n  \"keywords\": [],\n  \"license\": 0,\n  \"metadata_reason\": \"\",\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles";

    let payload = json!({
        "authors": (json!({})),
        "categories": (),
        "categories_by_source_id": (),
        "custom_fields": json!({}),
        "custom_fields_list": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "defined_type": "",
        "description": "",
        "doi": "",
        "funding": "",
        "funding_list": (
            json!({
                "id": 0,
                "title": ""
            })
        ),
        "group_id": 0,
        "handle": "",
        "is_metadata_record": false,
        "keywords": (),
        "license": 0,
        "metadata_reason": "",
        "references": (),
        "resource_doi": "",
        "resource_title": "",
        "tags": (),
        "timeline": json!({
            "firstOnline": "",
            "publisherAcceptance": "",
            "publisherPublication": ""
        }),
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

echo '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}' |  \
  http POST {{baseUrl}}/account/articles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {}\n  ],\n  "categories": [],\n  "categories_by_source_id": [],\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "defined_type": "",\n  "description": "",\n  "doi": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "group_id": 0,\n  "handle": "",\n  "is_metadata_record": false,\n  "keywords": [],\n  "license": 0,\n  "metadata_reason": "",\n  "references": [],\n  "resource_doi": "",\n  "resource_title": "",\n  "tags": [],\n  "timeline": {\n    "firstOnline": "",\n    "publisherAcceptance": "",\n    "publisherPublication": ""\n  },\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/articles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authors": [[]],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": [],
  "custom_fields_list": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    [
      "id": 0,
      "title": ""
    ]
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": [
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  ],
  "title": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "entity_id": 33334444
}

POST Create private link

{{baseUrl}}/account/articles/:article_id/private_links

BODY json

{
  "expires_date": "",
  "read_only": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/private_links");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/private_links" {:content-type :json
                                                                                       :form-params {:expires_date ""
                                                                                                     :read_only false}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/private_links"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/private_links"),
    Content = new StringContent("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/private_links");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/private_links"

	payload := strings.NewReader("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")

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

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

}

POST /baseUrl/account/articles/:article_id/private_links HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "expires_date": "",
  "read_only": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/private_links")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/private_links"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/private_links")
  .header("content-type", "application/json")
  .body("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
  .asString();

const data = JSON.stringify({
  expires_date: '',
  read_only: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/private_links');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/private_links',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '', read_only: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/private_links';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"","read_only":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/private_links',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expires_date": "",\n  "read_only": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/private_links',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({expires_date: '', read_only: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/private_links',
  headers: {'content-type': 'application/json'},
  body: {expires_date: '', read_only: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/private_links');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  expires_date: '',
  read_only: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/private_links',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '', read_only: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/private_links';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"","read_only":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expires_date": @"",
                              @"read_only": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/private_links"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/private_links" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/private_links",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'expires_date' => '',
    'read_only' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/private_links', [
  'body' => '{
  "expires_date": "",
  "read_only": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/private_links');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expires_date' => '',
  'read_only' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'expires_date' => '',
  'read_only' => null
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/private_links');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/private_links' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "",
  "read_only": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/private_links' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "",
  "read_only": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles/:article_id/private_links", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/private_links"

payload = {
    "expires_date": "",
    "read_only": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/private_links"

payload <- "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/private_links")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles/:article_id/private_links') do |req|
  req.body = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/private_links";

    let payload = json!({
        "expires_date": "",
        "read_only": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/private_links \
  --header 'content-type: application/json' \
  --data '{
  "expires_date": "",
  "read_only": false
}'

echo '{
  "expires_date": "",
  "read_only": false
}' |  \
  http POST {{baseUrl}}/account/articles/:article_id/private_links \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "expires_date": "",\n  "read_only": false\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/private_links

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "expires_date": "",
  "read_only": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/private_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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "html_location": "https://figshare.com/s/d5ec7a85bcd6dbe9d9b2",
  "token": "d5ec7a85bcd6dbe9d9b2"
}

DELETE Delete Article Embargo

{{baseUrl}}/account/articles/:article_id/embargo

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/embargo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id/embargo")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/embargo"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/embargo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/embargo");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/embargo"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id/embargo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id/embargo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/embargo"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/embargo")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id/embargo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id/embargo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/embargo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/embargo';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/embargo',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/embargo")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/embargo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/embargo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id/embargo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/embargo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/embargo';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/embargo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/embargo" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/embargo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id/embargo');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/embargo');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/embargo');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/embargo' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/embargo' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id/embargo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/embargo"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/embargo"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/embargo")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id/embargo') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/embargo";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id/embargo

http DELETE {{baseUrl}}/account/articles/:article_id/embargo

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/embargo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/embargo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete article author

{{baseUrl}}/account/articles/:article_id/authors/:author_id

QUERY PARAMS

article_id

author_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/authors/:author_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id/authors/:author_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/authors/:author_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/authors/:author_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/authors/:author_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/authors/:author_id"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id/authors/:author_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id/authors/:author_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/authors/:author_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors/:author_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id/authors/:author_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id/authors/:author_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/authors/:author_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/authors/:author_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/authors/:author_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors/:author_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/authors/:author_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/authors/:author_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id/authors/:author_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/authors/:author_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/authors/:author_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/authors/:author_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/authors/:author_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/authors/:author_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id/authors/:author_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/authors/:author_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/authors/:author_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/authors/:author_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/authors/:author_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id/authors/:author_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/authors/:author_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/authors/:author_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/authors/:author_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id/authors/:author_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/authors/:author_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id/authors/:author_id

http DELETE {{baseUrl}}/account/articles/:article_id/authors/:author_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/authors/:author_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/authors/:author_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete article category

{{baseUrl}}/account/articles/:article_id/categories/:category_id

QUERY PARAMS

article_id

category_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/categories/:category_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id/categories/:category_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/categories/:category_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/categories/:category_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/categories/:category_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/categories/:category_id"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id/categories/:category_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id/categories/:category_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/categories/:category_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories/:category_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id/categories/:category_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id/categories/:category_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/categories/:category_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/categories/:category_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/categories/:category_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories/:category_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/categories/:category_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/categories/:category_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id/categories/:category_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/categories/:category_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/categories/:category_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/categories/:category_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/categories/:category_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/categories/:category_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id/categories/:category_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/categories/:category_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/categories/:category_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/categories/:category_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/categories/:category_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id/categories/:category_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/categories/:category_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/categories/:category_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/categories/:category_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id/categories/:category_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/categories/:category_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id/categories/:category_id

http DELETE {{baseUrl}}/account/articles/:article_id/categories/:category_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/categories/:category_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/categories/:category_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete article confidentiality

{{baseUrl}}/account/articles/:article_id/confidentiality

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/confidentiality");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id/confidentiality")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/confidentiality"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/confidentiality"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/confidentiality");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/confidentiality"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id/confidentiality HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id/confidentiality")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/confidentiality"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id/confidentiality');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/confidentiality';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/confidentiality',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id/confidentiality');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/confidentiality';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/confidentiality"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/confidentiality" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/confidentiality",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id/confidentiality');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/confidentiality');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/confidentiality');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/confidentiality' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/confidentiality' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id/confidentiality")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/confidentiality"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/confidentiality"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/confidentiality")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id/confidentiality') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/confidentiality";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id/confidentiality

http DELETE {{baseUrl}}/account/articles/:article_id/confidentiality

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/confidentiality

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/confidentiality")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete article

{{baseUrl}}/account/articles/:article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id

http DELETE {{baseUrl}}/account/articles/:article_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Disable private link

{{baseUrl}}/account/articles/:article_id/private_links/:link_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/private_links/:link_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id/private_links/:link_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/private_links/:link_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/private_links/:link_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id/private_links/:link_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/private_links/:link_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id/private_links/:link_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/private_links/:link_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/private_links/:link_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id/private_links/:link_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/private_links/:link_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/private_links/:link_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/private_links/:link_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/private_links/:link_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id/private_links/:link_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/private_links/:link_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/private_links/:link_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/private_links/:link_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/private_links/:link_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id/private_links/:link_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id/private_links/:link_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/private_links/:link_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id/private_links/:link_id

http DELETE {{baseUrl}}/account/articles/:article_id/private_links/:link_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/private_links/:link_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/private_links/:link_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE File Delete

{{baseUrl}}/account/articles/:article_id/files/:file_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/files/:file_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/articles/:article_id/files/:file_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/files/:file_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/files/:file_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/files/:file_id"

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

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

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

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

}

DELETE /baseUrl/account/articles/:article_id/files/:file_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/files/:file_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/files/:file_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/files/:file_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/files/:file_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/files/:file_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/files/:file_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/files/:file_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/files/:file_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/files/:file_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/files/:file_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/files/:file_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/articles/:article_id/files/:file_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/files/:file_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/articles/:article_id/files/:file_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/files/:file_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/articles/:article_id/files/:file_id

http DELETE {{baseUrl}}/account/articles/:article_id/files/:file_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/files/:file_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/files/:file_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

POST Initiate Upload

{{baseUrl}}/account/articles/:article_id/files

BODY json

{
  "link": "",
  "md5": "",
  "name": "",
  "size": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/files");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/files" {:content-type :json
                                                                               :form-params {:link "http://figshare.com/file.txt"
                                                                                             :md5 "6c16e6e7d7587bd078e5117dda01d565"
                                                                                             :name "test.py"
                                                                                             :size 70}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/files"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/files"),
    Content = new StringContent("{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/files");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/files"

	payload := strings.NewReader("{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}")

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

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

}

POST /baseUrl/account/articles/:article_id/files HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/files")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/files"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/files")
  .header("content-type", "application/json")
  .body("{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}")
  .asString();

const data = JSON.stringify({
  link: 'http://figshare.com/file.txt',
  md5: '6c16e6e7d7587bd078e5117dda01d565',
  name: 'test.py',
  size: 70
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/files');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/files',
  headers: {'content-type': 'application/json'},
  data: {
    link: 'http://figshare.com/file.txt',
    md5: '6c16e6e7d7587bd078e5117dda01d565',
    name: 'test.py',
    size: 70
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/files';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"link":"http://figshare.com/file.txt","md5":"6c16e6e7d7587bd078e5117dda01d565","name":"test.py","size":70}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/files',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "link": "http://figshare.com/file.txt",\n  "md5": "6c16e6e7d7587bd078e5117dda01d565",\n  "name": "test.py",\n  "size": 70\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/files',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  link: 'http://figshare.com/file.txt',
  md5: '6c16e6e7d7587bd078e5117dda01d565',
  name: 'test.py',
  size: 70
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/files',
  headers: {'content-type': 'application/json'},
  body: {
    link: 'http://figshare.com/file.txt',
    md5: '6c16e6e7d7587bd078e5117dda01d565',
    name: 'test.py',
    size: 70
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/files');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  link: 'http://figshare.com/file.txt',
  md5: '6c16e6e7d7587bd078e5117dda01d565',
  name: 'test.py',
  size: 70
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/files',
  headers: {'content-type': 'application/json'},
  data: {
    link: 'http://figshare.com/file.txt',
    md5: '6c16e6e7d7587bd078e5117dda01d565',
    name: 'test.py',
    size: 70
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/files';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"link":"http://figshare.com/file.txt","md5":"6c16e6e7d7587bd078e5117dda01d565","name":"test.py","size":70}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"link": @"http://figshare.com/file.txt",
                              @"md5": @"6c16e6e7d7587bd078e5117dda01d565",
                              @"name": @"test.py",
                              @"size": @70 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/files"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/files" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/files",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'link' => 'http://figshare.com/file.txt',
    'md5' => '6c16e6e7d7587bd078e5117dda01d565',
    'name' => 'test.py',
    'size' => 70
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/files', [
  'body' => '{
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/files');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'link' => 'http://figshare.com/file.txt',
  'md5' => '6c16e6e7d7587bd078e5117dda01d565',
  'name' => 'test.py',
  'size' => 70
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'link' => 'http://figshare.com/file.txt',
  'md5' => '6c16e6e7d7587bd078e5117dda01d565',
  'name' => 'test.py',
  'size' => 70
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/files');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/files' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/files' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles/:article_id/files", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/files"

payload = {
    "link": "http://figshare.com/file.txt",
    "md5": "6c16e6e7d7587bd078e5117dda01d565",
    "name": "test.py",
    "size": 70
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/files"

payload <- "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/files")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles/:article_id/files') do |req|
  req.body = "{\n  \"link\": \"http://figshare.com/file.txt\",\n  \"md5\": \"6c16e6e7d7587bd078e5117dda01d565\",\n  \"name\": \"test.py\",\n  \"size\": 70\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/files";

    let payload = json!({
        "link": "http://figshare.com/file.txt",
        "md5": "6c16e6e7d7587bd078e5117dda01d565",
        "name": "test.py",
        "size": 70
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/files \
  --header 'content-type: application/json' \
  --data '{
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
}'

echo '{
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
}' |  \
  http POST {{baseUrl}}/account/articles/:article_id/files \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "link": "http://figshare.com/file.txt",\n  "md5": "6c16e6e7d7587bd078e5117dda01d565",\n  "name": "test.py",\n  "size": 70\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/files

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "link": "http://figshare.com/file.txt",
  "md5": "6c16e6e7d7587bd078e5117dda01d565",
  "name": "test.py",
  "size": 70
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/files")! 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()

POST Initiate a new Report

{{baseUrl}}/account/articles/export

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/export");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/export")

require "http/client"

url = "{{baseUrl}}/account/articles/export"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/export"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/export");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/export"

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

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

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

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

}

POST /baseUrl/account/articles/export HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/export")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/export"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/export")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/export")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/export');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/account/articles/export'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/export';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/export',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/export")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/export',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/account/articles/export'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/export');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/account/articles/export'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/export';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/export"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/export" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/export",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/export');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/export');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/export');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/export' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/export' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/articles/export")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/export"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/export"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/export")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/articles/export') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/export";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/export

http POST {{baseUrl}}/account/articles/export

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/articles/export

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "created_date": "2017-05-15T15:12:26Z",
  "download_url": "https://some.com/storage/path/123/report-456.xlsx"
}

GET List article authors

{{baseUrl}}/account/articles/:article_id/authors

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/authors");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/authors")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/authors"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/authors"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/authors");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/authors"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/authors HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/authors")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/authors"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/authors")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/authors');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/authors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/authors';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/authors',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/authors'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/authors');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/authors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/authors';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/authors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/authors" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/authors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/authors');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/authors');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/authors');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/authors' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/authors' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/authors")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/authors"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/authors"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/authors")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/authors') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/authors";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/authors

http GET {{baseUrl}}/account/articles/:article_id/authors

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/authors

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/authors")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "full_name": "John Doe",
    "id": 97657,
    "is_active": 1,
    "orcid_id": "1234-5678-9123-1234",
    "url_name": "John_Doe"
  }
]

GET List article categories

{{baseUrl}}/account/articles/:article_id/categories

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/categories")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/categories"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/categories"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/categories")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/categories');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/categories';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/categories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/categories'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/categories');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/categories';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/categories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/categories' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/categories")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/categories

http GET {{baseUrl}}/account/articles/:article_id/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": 11,
    "parent_id": 1,
    "path": "/450/1024/6532",
    "source_id": "300204",
    "taxonomy_id": 4,
    "title": "Anatomy"
  }
]

GET List article files (GET)

{{baseUrl}}/articles/:article_id/files

QUERY PARAMS

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id/files");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id/files")

require "http/client"

url = "{{baseUrl}}/articles/:article_id/files"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id/files"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id/files");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id/files"

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

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

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

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

}

GET /baseUrl/articles/:article_id/files HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id/files")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id/files"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/files")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id/files")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id/files');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/articles/:article_id/files'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id/files';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id/files',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/files")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id/files',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/articles/:article_id/files'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id/files');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/articles/:article_id/files'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id/files';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id/files"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id/files" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id/files",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id/files');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id/files');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id/files');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id/files' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id/files' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id/files")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id/files"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id/files"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id/files")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id/files') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id/files";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id/files

http GET {{baseUrl}}/articles/:article_id/files

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id/files

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id/files")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET List article files

{{baseUrl}}/account/articles/:article_id/files

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/files");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/files")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/files"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/files"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/files");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/files"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/files HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/files")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/files"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/files")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/files');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/files'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/files';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/files',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/files',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/files'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/files');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/files'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/files';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/files"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/files" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/files",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/files');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/files');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/files');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/files' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/files' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/files")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/files"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/files"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/files")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/files') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/files";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/files

http GET {{baseUrl}}/account/articles/:article_id/files

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/files

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/files")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "is_attached_to_public_version": true,
    "preview_state": "preview not available",
    "status": "created",
    "upload_token": "9dfc5fe3-d617-4d93-ac11-8afe7e984a4b",
    "upload_url": "https://uploads.figshare.com"
  }
]

GET List article versions

{{baseUrl}}/articles/:article_id/versions

QUERY PARAMS

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id/versions")

require "http/client"

url = "{{baseUrl}}/articles/:article_id/versions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id/versions"

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

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

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

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

}

GET /baseUrl/articles/:article_id/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id/versions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id/versions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id/versions';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id/versions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id/versions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id/versions';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id/versions")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id/versions

http GET {{baseUrl}}/articles/:article_id/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id/versions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET List private links

{{baseUrl}}/account/articles/:article_id/private_links

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/private_links");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/private_links")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/private_links"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/private_links"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/private_links");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/private_links"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/private_links HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/private_links")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/private_links"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/private_links")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/private_links');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/private_links'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/private_links';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/private_links',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/private_links',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/private_links'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/private_links');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/private_links'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/private_links';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/private_links"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/private_links" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/private_links",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/private_links');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/private_links');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/private_links');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/private_links' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/private_links' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/private_links")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/private_links"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/private_links"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/private_links")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/private_links') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/private_links";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/private_links

http GET {{baseUrl}}/account/articles/:article_id/private_links

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/private_links

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/private_links")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "expires_date": "2015-07-03T00:00:00",
    "html_location": "https://figshare.com/s/d5ec7a85bcd6dbe9d9b2",
    "id": "0cfb0dbeac92df445df4aba45f63fdc85fa0b9a888b64e157ce3c93b576aa300fb3621ef3a219515dd482",
    "is_active": true
  }
]

POST Private Article Publish

{{baseUrl}}/account/articles/:article_id/publish

QUERY PARAMS

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/publish");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/publish")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/publish"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/publish"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/publish"

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

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

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

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

}

POST /baseUrl/account/articles/:article_id/publish HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/publish")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/publish"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/publish")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/publish")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/publish');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/publish';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/publish',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/publish")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/publish',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/publish'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/publish');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/publish';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/publish"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/publish" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/publish",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/publish');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/publish');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/publish' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/publish' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/articles/:article_id/publish")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/publish"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/publish"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/publish")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/articles/:article_id/publish') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/publish";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/publish

http POST {{baseUrl}}/account/articles/:article_id/publish

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/publish

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/publish")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

POST Private Article Reserve DOI

{{baseUrl}}/account/articles/:article_id/reserve_doi

QUERY PARAMS

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/reserve_doi");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/reserve_doi")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/reserve_doi"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/reserve_doi"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/reserve_doi");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/reserve_doi"

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

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

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

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

}

POST /baseUrl/account/articles/:article_id/reserve_doi HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/reserve_doi")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/reserve_doi"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/reserve_doi")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/reserve_doi")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/reserve_doi');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/reserve_doi'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/reserve_doi';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/reserve_doi',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/reserve_doi")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/reserve_doi',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/reserve_doi'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/reserve_doi');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/reserve_doi'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/reserve_doi';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/reserve_doi"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/reserve_doi" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/reserve_doi",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/reserve_doi');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/reserve_doi');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/reserve_doi');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/reserve_doi' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/reserve_doi' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/articles/:article_id/reserve_doi")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/reserve_doi"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/reserve_doi"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/reserve_doi")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/articles/:article_id/reserve_doi') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/reserve_doi";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/reserve_doi

http POST {{baseUrl}}/account/articles/:article_id/reserve_doi

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/reserve_doi

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/reserve_doi")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "doi": "10.5072/FK2.FIGSHARE.20345"
}

POST Private Article Reserve Handle

{{baseUrl}}/account/articles/:article_id/reserve_handle

QUERY PARAMS

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/reserve_handle");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/reserve_handle")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/reserve_handle"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/reserve_handle"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/reserve_handle");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/reserve_handle"

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

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

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

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

}

POST /baseUrl/account/articles/:article_id/reserve_handle HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/reserve_handle")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/reserve_handle"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/reserve_handle")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/reserve_handle")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/reserve_handle');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/reserve_handle'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/reserve_handle';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/reserve_handle',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/reserve_handle")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/reserve_handle',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/reserve_handle'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/reserve_handle');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/reserve_handle'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/reserve_handle';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/reserve_handle"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/reserve_handle" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/reserve_handle",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/reserve_handle');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/reserve_handle');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/reserve_handle');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/reserve_handle' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/reserve_handle' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/articles/:article_id/reserve_handle")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/reserve_handle"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/reserve_handle"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/reserve_handle")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/articles/:article_id/reserve_handle') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/reserve_handle";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/reserve_handle

http POST {{baseUrl}}/account/articles/:article_id/reserve_handle

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/reserve_handle

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/reserve_handle")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "handle": "11172/FK2.FIGSHARE.20345"
}

POST Private Article Resource

{{baseUrl}}/account/articles/:article_id/resource

QUERY PARAMS

article_id

BODY json

{
  "doi": "",
  "id": "",
  "link": "",
  "status": "",
  "title": "",
  "version": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/resource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/:article_id/resource" {:content-type :json
                                                                                  :form-params {:id "aaaa23512"
                                                                                                :link "https://docs.figshare.com"
                                                                                                :status "frozen"
                                                                                                :title "Test title"
                                                                                                :version 1}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/resource"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/resource"),
    Content = new StringContent("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/resource");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/resource"

	payload := strings.NewReader("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")

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

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

}

POST /baseUrl/account/articles/:article_id/resource HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/:article_id/resource")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/resource"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/resource")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/:article_id/resource")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
  .asString();

const data = JSON.stringify({
  id: 'aaaa23512',
  link: 'https://docs.figshare.com',
  status: 'frozen',
  title: 'Test title',
  version: 1
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/:article_id/resource');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/resource',
  headers: {'content-type': 'application/json'},
  data: {
    id: 'aaaa23512',
    link: 'https://docs.figshare.com',
    status: 'frozen',
    title: 'Test title',
    version: 1
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/resource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"aaaa23512","link":"https://docs.figshare.com","status":"frozen","title":"Test title","version":1}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/resource',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "aaaa23512",\n  "link": "https://docs.figshare.com",\n  "status": "frozen",\n  "title": "Test title",\n  "version": 1\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/resource")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/resource',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  id: 'aaaa23512',
  link: 'https://docs.figshare.com',
  status: 'frozen',
  title: 'Test title',
  version: 1
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/resource',
  headers: {'content-type': 'application/json'},
  body: {
    id: 'aaaa23512',
    link: 'https://docs.figshare.com',
    status: 'frozen',
    title: 'Test title',
    version: 1
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/:article_id/resource');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: 'aaaa23512',
  link: 'https://docs.figshare.com',
  status: 'frozen',
  title: 'Test title',
  version: 1
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/:article_id/resource',
  headers: {'content-type': 'application/json'},
  data: {
    id: 'aaaa23512',
    link: 'https://docs.figshare.com',
    status: 'frozen',
    title: 'Test title',
    version: 1
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/resource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"aaaa23512","link":"https://docs.figshare.com","status":"frozen","title":"Test title","version":1}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @"aaaa23512",
                              @"link": @"https://docs.figshare.com",
                              @"status": @"frozen",
                              @"title": @"Test title",
                              @"version": @1 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/resource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/resource" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/resource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => 'aaaa23512',
    'link' => 'https://docs.figshare.com',
    'status' => 'frozen',
    'title' => 'Test title',
    'version' => 1
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/:article_id/resource', [
  'body' => '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/resource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => 'aaaa23512',
  'link' => 'https://docs.figshare.com',
  'status' => 'frozen',
  'title' => 'Test title',
  'version' => 1
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => 'aaaa23512',
  'link' => 'https://docs.figshare.com',
  'status' => 'frozen',
  'title' => 'Test title',
  'version' => 1
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/resource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/resource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/resource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles/:article_id/resource", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/resource"

payload = {
    "id": "aaaa23512",
    "link": "https://docs.figshare.com",
    "status": "frozen",
    "title": "Test title",
    "version": 1
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/resource"

payload <- "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/resource")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles/:article_id/resource') do |req|
  req.body = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/resource";

    let payload = json!({
        "id": "aaaa23512",
        "link": "https://docs.figshare.com",
        "status": "frozen",
        "title": "Test title",
        "version": 1
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/:article_id/resource \
  --header 'content-type: application/json' \
  --data '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}'

echo '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}' |  \
  http POST {{baseUrl}}/account/articles/:article_id/resource \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "aaaa23512",\n  "link": "https://docs.figshare.com",\n  "status": "frozen",\n  "title": "Test title",\n  "version": 1\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/resource

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/resource")! 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()

POST Private Articles search

{{baseUrl}}/account/articles/search

BODY json

{
  "resource_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resource_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/articles/search" {:content-type :json
                                                                    :form-params {:resource_id ""}})

require "http/client"

url = "{{baseUrl}}/account/articles/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resource_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/articles/search"),
    Content = new StringContent("{\n  \"resource_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resource_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/search"

	payload := strings.NewReader("{\n  \"resource_id\": \"\"\n}")

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

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

}

POST /baseUrl/account/articles/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "resource_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/articles/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resource_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resource_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resource_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/articles/search")
  .header("content-type", "application/json")
  .body("{\n  \"resource_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resource_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/articles/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/search',
  headers: {'content-type': 'application/json'},
  data: {resource_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resource_id":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resource_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resource_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/search',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resource_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/search',
  headers: {'content-type': 'application/json'},
  body: {resource_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/articles/search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resource_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/articles/search',
  headers: {'content-type': 'application/json'},
  data: {resource_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resource_id":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resource_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resource_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resource_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/articles/search', [
  'body' => '{
  "resource_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resource_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resource_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/search');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resource_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resource_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resource_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/articles/search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/search"

payload = { "resource_id": "" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/search"

payload <- "{\n  \"resource_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/search")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"resource_id\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/articles/search') do |req|
  req.body = "{\n  \"resource_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/search";

    let payload = json!({"resource_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/articles/search \
  --header 'content-type: application/json' \
  --data '{
  "resource_id": ""
}'

echo '{
  "resource_id": ""
}' |  \
  http POST {{baseUrl}}/account/articles/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resource_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["resource_id": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/search")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "project_id": 1
  }
]

GET Private Articles

{{baseUrl}}/account/articles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles")

require "http/client"

url = "{{baseUrl}}/account/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles"

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

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

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

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

}

GET /baseUrl/account/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/articles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/articles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/articles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles

http GET {{baseUrl}}/account/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "defined_type": 3,
    "defined_type_name": "media",
    "doi": "10.6084/m9.figshare.1434614",
    "group_id": 1234,
    "handle": "111184/figshare.1234",
    "id": 1434614,
    "published_date": "2015-12-31T23:59:59.000Z",
    "thumb": "https://ndownloader.figshare.com/files/123456789/preview/12345678/thumb.png",
    "title": "Test article title",
    "url": "http://api.figshare.com/articles/1434614",
    "url_private_api": "https://api.figshare.com/account/articles/1434614",
    "url_private_html": "https://figshare.com/account/articles/1434614",
    "url_public_api": "https://api.figshare.com/articles/1434614",
    "url_public_html": "https://figshare.com/articles/media/Test_article_title/1434614"
  }
]

GET Public Article Confidentiality for article version

{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality

QUERY PARAMS

article_id

v_number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")

require "http/client"

url = "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"

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

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

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

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

}

GET /baseUrl/articles/:article_id/versions/:v_number/confidentiality HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id/versions/:v_number/confidentiality',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id/versions/:v_number/confidentiality")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id/versions/:v_number/confidentiality') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality

http GET {{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id/versions/:v_number/confidentiality")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET Public Article Embargo for article version

{{baseUrl}}/articles/:article_id/versions/:v_number/embargo

QUERY PARAMS

article_id

v_number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")

require "http/client"

url = "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"

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

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

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

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

}

GET /baseUrl/articles/:article_id/versions/:v_number/embargo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id/versions/:v_number/embargo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id/versions/:v_number/embargo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id/versions/:v_number/embargo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id/versions/:v_number/embargo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id/versions/:v_number/embargo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id/versions/:v_number/embargo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id/versions/:v_number/embargo

http GET {{baseUrl}}/articles/:article_id/versions/:v_number/embargo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id/versions/:v_number/embargo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id/versions/:v_number/embargo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

POST Public Articles Search

{{baseUrl}}/articles/search

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/search");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/articles/search")

require "http/client"

url = "{{baseUrl}}/articles/search"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/articles/search"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/search");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/search"

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

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

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

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

}

POST /baseUrl/articles/search HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/articles/search")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/search"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/search")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/articles/search")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/articles/search');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/articles/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/search';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/search',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/search")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/search',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/articles/search'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/articles/search');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/articles/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/search';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/search" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/articles/search');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/search');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/search');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/search' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/search' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/articles/search")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/search"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/search"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/search")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/articles/search') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/search";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/articles/search

http POST {{baseUrl}}/articles/search

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/articles/search

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

GET Public Articles

{{baseUrl}}/articles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles")

require "http/client"

url = "{{baseUrl}}/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles"

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

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

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

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

}

GET /baseUrl/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/articles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/articles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/articles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles

http GET {{baseUrl}}/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

PUT Replace article authors

{{baseUrl}}/account/articles/:article_id/authors

BODY json

{
  "authors": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/authors");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/authors" {:content-type :json
                                                                                :form-params {:authors [{:id 12121} {:id 34345} {:name "John Doe"}]}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/authors"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/authors"),
    Content = new StringContent("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/authors");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/authors"

	payload := strings.NewReader("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/authors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 121

{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/authors")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/authors"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/authors")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/authors');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/authors';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/authors")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/authors',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  headers: {'content-type': 'application/json'},
  body: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/authors');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/authors';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{ @"id": @12121 }, @{ @"id": @34345 }, @{ @"name": @"John Doe" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/authors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/authors" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/authors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                'id' => 12121
        ],
        [
                'id' => 34345
        ],
        [
                'name' => 'John Doe'
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/authors', [
  'body' => '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/authors');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/authors');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/authors' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/authors' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/authors", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/authors"

payload = { "authors": [{ "id": 12121 }, { "id": 34345 }, { "name": "John Doe" }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/authors"

payload <- "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/authors")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/authors') do |req|
  req.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/authors";

    let payload = json!({"authors": (json!({"id": 12121}), json!({"id": 34345}), json!({"name": "John Doe"}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/authors \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

echo '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/authors \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/authors

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["authors": [["id": 12121], ["id": 34345], ["name": "John Doe"]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/authors")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Replace article categories

{{baseUrl}}/account/articles/:article_id/categories

BODY json

{
  "categories": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/categories" {:content-type :json
                                                                                   :form-params {:categories [1 10 11]}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/categories"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/categories"),
    Content = new StringContent("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/categories");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/categories"

	payload := strings.NewReader("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/categories HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "categories": [
    1,
    10,
    11
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/categories")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/categories"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/categories")
  .header("content-type", "application/json")
  .body("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .asString();

const data = JSON.stringify({
  categories: [
    1,
    10,
    11
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/categories');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/categories';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/categories")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/categories',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({categories: [1, 10, 11]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  headers: {'content-type': 'application/json'},
  body: {categories: [1, 10, 11]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/categories');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  categories: [
    1,
    10,
    11
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/categories';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"categories": @[ @1, @10, @11 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/categories" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'categories' => [
        1,
        10,
        11
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/categories', [
  'body' => '{
  "categories": [
    1,
    10,
    11
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/categories');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/categories');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/categories' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/categories' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/categories", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/categories"

payload = { "categories": [1, 10, 11] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/categories"

payload <- "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/categories")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/categories') do |req|
  req.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/categories";

    let payload = json!({"categories": (1, 10, 11)});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/categories \
  --header 'content-type: application/json' \
  --data '{
  "categories": [
    1,
    10,
    11
  ]
}'

echo '{
  "categories": [
    1,
    10,
    11
  ]
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/categories \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/categories

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["categories": [1, 10, 11]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

GET Single File

{{baseUrl}}/account/articles/:article_id/files/:file_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/files/:file_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/articles/:article_id/files/:file_id")

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/files/:file_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/files/:file_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/files/:file_id"

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

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

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

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

}

GET /baseUrl/account/articles/:article_id/files/:file_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/files/:file_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/files/:file_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/files/:file_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/files/:file_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/files/:file_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/files/:file_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/files/:file_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/files/:file_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/articles/:article_id/files/:file_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/files/:file_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/articles/:article_id/files/:file_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/files/:file_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/files/:file_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/articles/:article_id/files/:file_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/files/:file_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/files/:file_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/articles/:article_id/files/:file_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/files/:file_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/articles/:article_id/files/:file_id

http GET {{baseUrl}}/account/articles/:article_id/files/:file_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/files/:file_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/files/:file_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "is_attached_to_public_version": true,
  "preview_state": "preview not available",
  "status": "created",
  "upload_token": "9dfc5fe3-d617-4d93-ac11-8afe7e984a4b",
  "upload_url": "https://uploads.figshare.com"
}

PUT Update Article Embargo

{{baseUrl}}/account/articles/:article_id/embargo

BODY json

{
  "embargo_date": "",
  "embargo_options": [
    {}
  ],
  "embargo_reason": "",
  "embargo_title": "",
  "embargo_type": "",
  "is_embargoed": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/embargo");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/embargo" {:content-type :json
                                                                                :form-params {:embargo_date "2018-05-22T04:04:04"
                                                                                              :embargo_options [{:id 1321} {:id 3345} {:group_ids [4332 5433 678]
                                                                                                                 :id 54621}]
                                                                                              :embargo_reason ""
                                                                                              :embargo_title "File(s) under embargo"
                                                                                              :embargo_type "file"
                                                                                              :is_embargoed true}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/embargo"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/embargo"),
    Content = new StringContent("{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/embargo");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/embargo"

	payload := strings.NewReader("{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/embargo HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 349

{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "id": 1321
    },
    {
      "id": 3345
    },
    {
      "group_ids": [
        4332,
        5433,
        678
      ],
      "id": 54621
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/embargo")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/embargo"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/embargo")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/embargo")
  .header("content-type", "application/json")
  .body("{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}")
  .asString();

const data = JSON.stringify({
  embargo_date: '2018-05-22T04:04:04',
  embargo_options: [
    {
      id: 1321
    },
    {
      id: 3345
    },
    {
      group_ids: [
        4332,
        5433,
        678
      ],
      id: 54621
    }
  ],
  embargo_reason: '',
  embargo_title: 'File(s) under embargo',
  embargo_type: 'file',
  is_embargoed: true
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/embargo');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/embargo',
  headers: {'content-type': 'application/json'},
  data: {
    embargo_date: '2018-05-22T04:04:04',
    embargo_options: [{id: 1321}, {id: 3345}, {group_ids: [4332, 5433, 678], id: 54621}],
    embargo_reason: '',
    embargo_title: 'File(s) under embargo',
    embargo_type: 'file',
    is_embargoed: true
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/embargo';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"embargo_date":"2018-05-22T04:04:04","embargo_options":[{"id":1321},{"id":3345},{"group_ids":[4332,5433,678],"id":54621}],"embargo_reason":"","embargo_title":"File(s) under embargo","embargo_type":"file","is_embargoed":true}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/embargo',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "embargo_date": "2018-05-22T04:04:04",\n  "embargo_options": [\n    {\n      "id": 1321\n    },\n    {\n      "id": 3345\n    },\n    {\n      "group_ids": [\n        4332,\n        5433,\n        678\n      ],\n      "id": 54621\n    }\n  ],\n  "embargo_reason": "",\n  "embargo_title": "File(s) under embargo",\n  "embargo_type": "file",\n  "is_embargoed": true\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/embargo")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/embargo',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  embargo_date: '2018-05-22T04:04:04',
  embargo_options: [{id: 1321}, {id: 3345}, {group_ids: [4332, 5433, 678], id: 54621}],
  embargo_reason: '',
  embargo_title: 'File(s) under embargo',
  embargo_type: 'file',
  is_embargoed: true
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/embargo',
  headers: {'content-type': 'application/json'},
  body: {
    embargo_date: '2018-05-22T04:04:04',
    embargo_options: [{id: 1321}, {id: 3345}, {group_ids: [4332, 5433, 678], id: 54621}],
    embargo_reason: '',
    embargo_title: 'File(s) under embargo',
    embargo_type: 'file',
    is_embargoed: true
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/embargo');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  embargo_date: '2018-05-22T04:04:04',
  embargo_options: [
    {
      id: 1321
    },
    {
      id: 3345
    },
    {
      group_ids: [
        4332,
        5433,
        678
      ],
      id: 54621
    }
  ],
  embargo_reason: '',
  embargo_title: 'File(s) under embargo',
  embargo_type: 'file',
  is_embargoed: true
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/embargo',
  headers: {'content-type': 'application/json'},
  data: {
    embargo_date: '2018-05-22T04:04:04',
    embargo_options: [{id: 1321}, {id: 3345}, {group_ids: [4332, 5433, 678], id: 54621}],
    embargo_reason: '',
    embargo_title: 'File(s) under embargo',
    embargo_type: 'file',
    is_embargoed: true
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/embargo';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"embargo_date":"2018-05-22T04:04:04","embargo_options":[{"id":1321},{"id":3345},{"group_ids":[4332,5433,678],"id":54621}],"embargo_reason":"","embargo_title":"File(s) under embargo","embargo_type":"file","is_embargoed":true}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"embargo_date": @"2018-05-22T04:04:04",
                              @"embargo_options": @[ @{ @"id": @1321 }, @{ @"id": @3345 }, @{ @"group_ids": @[ @4332, @5433, @678 ], @"id": @54621 } ],
                              @"embargo_reason": @"",
                              @"embargo_title": @"File(s) under embargo",
                              @"embargo_type": @"file",
                              @"is_embargoed": @YES };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/embargo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/embargo" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/embargo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'embargo_date' => '2018-05-22T04:04:04',
    'embargo_options' => [
        [
                'id' => 1321
        ],
        [
                'id' => 3345
        ],
        [
                'group_ids' => [
                                4332,
                                5433,
                                678
                ],
                'id' => 54621
        ]
    ],
    'embargo_reason' => '',
    'embargo_title' => 'File(s) under embargo',
    'embargo_type' => 'file',
    'is_embargoed' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/embargo', [
  'body' => '{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "id": 1321
    },
    {
      "id": 3345
    },
    {
      "group_ids": [
        4332,
        5433,
        678
      ],
      "id": 54621
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/embargo');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'embargo_date' => '2018-05-22T04:04:04',
  'embargo_options' => [
    [
        'id' => 1321
    ],
    [
        'id' => 3345
    ],
    [
        'group_ids' => [
                4332,
                5433,
                678
        ],
        'id' => 54621
    ]
  ],
  'embargo_reason' => '',
  'embargo_title' => 'File(s) under embargo',
  'embargo_type' => 'file',
  'is_embargoed' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'embargo_date' => '2018-05-22T04:04:04',
  'embargo_options' => [
    [
        'id' => 1321
    ],
    [
        'id' => 3345
    ],
    [
        'group_ids' => [
                4332,
                5433,
                678
        ],
        'id' => 54621
    ]
  ],
  'embargo_reason' => '',
  'embargo_title' => 'File(s) under embargo',
  'embargo_type' => 'file',
  'is_embargoed' => null
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/embargo');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/embargo' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "id": 1321
    },
    {
      "id": 3345
    },
    {
      "group_ids": [
        4332,
        5433,
        678
      ],
      "id": 54621
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/embargo' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "id": 1321
    },
    {
      "id": 3345
    },
    {
      "group_ids": [
        4332,
        5433,
        678
      ],
      "id": 54621
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/embargo", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/embargo"

payload = {
    "embargo_date": "2018-05-22T04:04:04",
    "embargo_options": [
        { "id": 1321 },
        { "id": 3345 },
        {
            "group_ids": [4332, 5433, 678],
            "id": 54621
        }
    ],
    "embargo_reason": "",
    "embargo_title": "File(s) under embargo",
    "embargo_type": "file",
    "is_embargoed": True
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/embargo"

payload <- "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/embargo")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/embargo') do |req|
  req.body = "{\n  \"embargo_date\": \"2018-05-22T04:04:04\",\n  \"embargo_options\": [\n    {\n      \"id\": 1321\n    },\n    {\n      \"id\": 3345\n    },\n    {\n      \"group_ids\": [\n        4332,\n        5433,\n        678\n      ],\n      \"id\": 54621\n    }\n  ],\n  \"embargo_reason\": \"\",\n  \"embargo_title\": \"File(s) under embargo\",\n  \"embargo_type\": \"file\",\n  \"is_embargoed\": true\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/embargo";

    let payload = json!({
        "embargo_date": "2018-05-22T04:04:04",
        "embargo_options": (
            json!({"id": 1321}),
            json!({"id": 3345}),
            json!({
                "group_ids": (4332, 5433, 678),
                "id": 54621
            })
        ),
        "embargo_reason": "",
        "embargo_title": "File(s) under embargo",
        "embargo_type": "file",
        "is_embargoed": true
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/embargo \
  --header 'content-type: application/json' \
  --data '{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "id": 1321
    },
    {
      "id": 3345
    },
    {
      "group_ids": [
        4332,
        5433,
        678
      ],
      "id": 54621
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
}'

echo '{
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    {
      "id": 1321
    },
    {
      "id": 3345
    },
    {
      "group_ids": [
        4332,
        5433,
        678
      ],
      "id": 54621
    }
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/embargo \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "embargo_date": "2018-05-22T04:04:04",\n  "embargo_options": [\n    {\n      "id": 1321\n    },\n    {\n      "id": 3345\n    },\n    {\n      "group_ids": [\n        4332,\n        5433,\n        678\n      ],\n      "id": 54621\n    }\n  ],\n  "embargo_reason": "",\n  "embargo_title": "File(s) under embargo",\n  "embargo_type": "file",\n  "is_embargoed": true\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/embargo

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "embargo_date": "2018-05-22T04:04:04",
  "embargo_options": [
    ["id": 1321],
    ["id": 3345],
    [
      "group_ids": [4332, 5433, 678],
      "id": 54621
    ]
  ],
  "embargo_reason": "",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "file",
  "is_embargoed": true
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/embargo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update article confidentiality

{{baseUrl}}/account/articles/:article_id/confidentiality

BODY json

{
  "reason": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/confidentiality");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/confidentiality" {:content-type :json
                                                                                        :form-params {:reason ""}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/confidentiality"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reason\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/confidentiality"),
    Content = new StringContent("{\n  \"reason\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/confidentiality");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/confidentiality"

	payload := strings.NewReader("{\n  \"reason\": \"\"\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/confidentiality HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/confidentiality")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/confidentiality"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"reason\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .header("content-type", "application/json")
  .body("{\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/confidentiality');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality',
  headers: {'content-type': 'application/json'},
  data: {reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/confidentiality';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reason":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/confidentiality")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/confidentiality',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality',
  headers: {'content-type': 'application/json'},
  body: {reason: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/confidentiality');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  reason: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/confidentiality',
  headers: {'content-type': 'application/json'},
  data: {reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/confidentiality';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reason":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/confidentiality"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/confidentiality" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/confidentiality",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/confidentiality', [
  'body' => '{
  "reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/confidentiality');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/confidentiality');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/confidentiality' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reason": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/confidentiality' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"reason\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/confidentiality", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/confidentiality"

payload = { "reason": "" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/confidentiality"

payload <- "{\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/confidentiality")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"reason\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/confidentiality') do |req|
  req.body = "{\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/confidentiality";

    let payload = json!({"reason": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/confidentiality \
  --header 'content-type: application/json' \
  --data '{
  "reason": ""
}'

echo '{
  "reason": ""
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/confidentiality \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "reason": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/confidentiality

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["reason": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/confidentiality")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update article version thumbnail

{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb

QUERY PARAMS

article_id

version_id

BODY json

{
  "file_id": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"file_id\": 123\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb" {:content-type :json
                                                                                                          :form-params {:file_id 123}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"file_id\": 123\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"),
    Content = new StringContent("{\n  \"file_id\": 123\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"file_id\": 123\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"

	payload := strings.NewReader("{\n  \"file_id\": 123\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/versions/:version_id/update_thumb HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "file_id": 123
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"file_id\": 123\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"file_id\": 123\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"file_id\": 123\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb")
  .header("content-type", "application/json")
  .body("{\n  \"file_id\": 123\n}")
  .asString();

const data = JSON.stringify({
  file_id: 123
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb',
  headers: {'content-type': 'application/json'},
  data: {file_id: 123}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"file_id":123}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "file_id": 123\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"file_id\": 123\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/versions/:version_id/update_thumb',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({file_id: 123}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb',
  headers: {'content-type': 'application/json'},
  body: {file_id: 123},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  file_id: 123
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb',
  headers: {'content-type': 'application/json'},
  data: {file_id: 123}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"file_id":123}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"file_id": @123 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"file_id\": 123\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'file_id' => 123
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb', [
  'body' => '{
  "file_id": 123
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'file_id' => 123
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'file_id' => 123
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "file_id": 123
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "file_id": 123
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"file_id\": 123\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/versions/:version_id/update_thumb", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"

payload = { "file_id": 123 }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb"

payload <- "{\n  \"file_id\": 123\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"file_id\": 123\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/versions/:version_id/update_thumb') do |req|
  req.body = "{\n  \"file_id\": 123\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb";

    let payload = json!({"file_id": 123});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb \
  --header 'content-type: application/json' \
  --data '{
  "file_id": 123
}'

echo '{
  "file_id": 123
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "file_id": 123\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["file_id": 123] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/versions/:version_id/update_thumb")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update article version

{{baseUrl}}/account/articles/:article_id/versions/:version_id/

QUERY PARAMS

article_id

version_id

BODY json

{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/versions/:version_id/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/versions/:version_id/" {:content-type :json
                                                                                              :form-params {:authors [{:name "John Doe"} {:id 1000008}]
                                                                                                            :categories [1 10 11]
                                                                                                            :categories_by_source_id ["300204" "400207"]
                                                                                                            :custom_fields {:defined_key "value for it"}
                                                                                                            :defined_type "media"
                                                                                                            :description "Test description of article"
                                                                                                            :is_metadata_record true
                                                                                                            :keywords ["tag1" "tag2"]
                                                                                                            :license 1
                                                                                                            :metadata_reason "hosted somewhere else"
                                                                                                            :references ["http://figshare.com" "http://api.figshare.com"]
                                                                                                            :tags ["tag1" "tag2"]
                                                                                                            :timeline {:firstOnline "2015-12-31"
                                                                                                                       :publisherAcceptance "2015-12-31"
                                                                                                                       :publisherPublication "2015-12-31"}
                                                                                                            :title "Test article title"}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/versions/:version_id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/versions/:version_id/"),
    Content = new StringContent("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/versions/:version_id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/versions/:version_id/"

	payload := strings.NewReader("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/versions/:version_id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 760

{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/versions/:version_id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/versions/:version_id/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/versions/:version_id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/versions/:version_id/")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {
      name: 'John Doe'
    },
    {
      id: 1000008
    }
  ],
  categories: [
    1,
    10,
    11
  ],
  categories_by_source_id: [
    '300204',
    '400207'
  ],
  custom_fields: {
    defined_key: 'value for it'
  },
  defined_type: 'media',
  description: 'Test description of article',
  is_metadata_record: true,
  keywords: [
    'tag1',
    'tag2'
  ],
  license: 1,
  metadata_reason: 'hosted somewhere else',
  references: [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  tags: [
    'tag1',
    'tag2'
  ],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test article title'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/versions/:version_id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{name: 'John Doe'}, {id: 1000008}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    defined_type: 'media',
    description: 'Test description of article',
    is_metadata_record: true,
    keywords: ['tag1', 'tag2'],
    license: 1,
    metadata_reason: 'hosted somewhere else',
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test article title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/versions/:version_id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"name":"John Doe"},{"id":1000008}],"categories":[1,10,11],"categories_by_source_id":["300204","400207"],"custom_fields":{"defined_key":"value for it"},"defined_type":"media","description":"Test description of article","is_metadata_record":true,"keywords":["tag1","tag2"],"license":1,"metadata_reason":"hosted somewhere else","references":["http://figshare.com","http://api.figshare.com"],"tags":["tag1","tag2"],"timeline":{"firstOnline":"2015-12-31","publisherAcceptance":"2015-12-31","publisherPublication":"2015-12-31"},"title":"Test article title"}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {\n      "name": "John Doe"\n    },\n    {\n      "id": 1000008\n    }\n  ],\n  "categories": [\n    1,\n    10,\n    11\n  ],\n  "categories_by_source_id": [\n    "300204",\n    "400207"\n  ],\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "defined_type": "media",\n  "description": "Test description of article",\n  "is_metadata_record": true,\n  "keywords": [\n    "tag1",\n    "tag2"\n  ],\n  "license": 1,\n  "metadata_reason": "hosted somewhere else",\n  "references": [\n    "http://figshare.com",\n    "http://api.figshare.com"\n  ],\n  "tags": [\n    "tag1",\n    "tag2"\n  ],\n  "timeline": {\n    "firstOnline": "2015-12-31",\n    "publisherAcceptance": "2015-12-31",\n    "publisherPublication": "2015-12-31"\n  },\n  "title": "Test article title"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/versions/:version_id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/versions/:version_id/',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  authors: [{name: 'John Doe'}, {id: 1000008}],
  categories: [1, 10, 11],
  categories_by_source_id: ['300204', '400207'],
  custom_fields: {defined_key: 'value for it'},
  defined_type: 'media',
  description: 'Test description of article',
  is_metadata_record: true,
  keywords: ['tag1', 'tag2'],
  license: 1,
  metadata_reason: 'hosted somewhere else',
  references: ['http://figshare.com', 'http://api.figshare.com'],
  tags: ['tag1', 'tag2'],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test article title'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/',
  headers: {'content-type': 'application/json'},
  body: {
    authors: [{name: 'John Doe'}, {id: 1000008}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    defined_type: 'media',
    description: 'Test description of article',
    is_metadata_record: true,
    keywords: ['tag1', 'tag2'],
    license: 1,
    metadata_reason: 'hosted somewhere else',
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test article title'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/versions/:version_id/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {
      name: 'John Doe'
    },
    {
      id: 1000008
    }
  ],
  categories: [
    1,
    10,
    11
  ],
  categories_by_source_id: [
    '300204',
    '400207'
  ],
  custom_fields: {
    defined_key: 'value for it'
  },
  defined_type: 'media',
  description: 'Test description of article',
  is_metadata_record: true,
  keywords: [
    'tag1',
    'tag2'
  ],
  license: 1,
  metadata_reason: 'hosted somewhere else',
  references: [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  tags: [
    'tag1',
    'tag2'
  ],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test article title'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/versions/:version_id/',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{name: 'John Doe'}, {id: 1000008}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    defined_type: 'media',
    description: 'Test description of article',
    is_metadata_record: true,
    keywords: ['tag1', 'tag2'],
    license: 1,
    metadata_reason: 'hosted somewhere else',
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test article title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/versions/:version_id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"name":"John Doe"},{"id":1000008}],"categories":[1,10,11],"categories_by_source_id":["300204","400207"],"custom_fields":{"defined_key":"value for it"},"defined_type":"media","description":"Test description of article","is_metadata_record":true,"keywords":["tag1","tag2"],"license":1,"metadata_reason":"hosted somewhere else","references":["http://figshare.com","http://api.figshare.com"],"tags":["tag1","tag2"],"timeline":{"firstOnline":"2015-12-31","publisherAcceptance":"2015-12-31","publisherPublication":"2015-12-31"},"title":"Test article title"}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{ @"name": @"John Doe" }, @{ @"id": @1000008 } ],
                              @"categories": @[ @1, @10, @11 ],
                              @"categories_by_source_id": @[ @"300204", @"400207" ],
                              @"custom_fields": @{ @"defined_key": @"value for it" },
                              @"defined_type": @"media",
                              @"description": @"Test description of article",
                              @"is_metadata_record": @YES,
                              @"keywords": @[ @"tag1", @"tag2" ],
                              @"license": @1,
                              @"metadata_reason": @"hosted somewhere else",
                              @"references": @[ @"http://figshare.com", @"http://api.figshare.com" ],
                              @"tags": @[ @"tag1", @"tag2" ],
                              @"timeline": @{ @"firstOnline": @"2015-12-31", @"publisherAcceptance": @"2015-12-31", @"publisherPublication": @"2015-12-31" },
                              @"title": @"Test article title" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/versions/:version_id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/versions/:version_id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/versions/:version_id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                'name' => 'John Doe'
        ],
        [
                'id' => 1000008
        ]
    ],
    'categories' => [
        1,
        10,
        11
    ],
    'categories_by_source_id' => [
        '300204',
        '400207'
    ],
    'custom_fields' => [
        'defined_key' => 'value for it'
    ],
    'defined_type' => 'media',
    'description' => 'Test description of article',
    'is_metadata_record' => null,
    'keywords' => [
        'tag1',
        'tag2'
    ],
    'license' => 1,
    'metadata_reason' => 'hosted somewhere else',
    'references' => [
        'http://figshare.com',
        'http://api.figshare.com'
    ],
    'tags' => [
        'tag1',
        'tag2'
    ],
    'timeline' => [
        'firstOnline' => '2015-12-31',
        'publisherAcceptance' => '2015-12-31',
        'publisherPublication' => '2015-12-31'
    ],
    'title' => 'Test article title'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/versions/:version_id/', [
  'body' => '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/versions/:version_id/');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        'name' => 'John Doe'
    ],
    [
        'id' => 1000008
    ]
  ],
  'categories' => [
    1,
    10,
    11
  ],
  'categories_by_source_id' => [
    '300204',
    '400207'
  ],
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'defined_type' => 'media',
  'description' => 'Test description of article',
  'is_metadata_record' => null,
  'keywords' => [
    'tag1',
    'tag2'
  ],
  'license' => 1,
  'metadata_reason' => 'hosted somewhere else',
  'references' => [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  'tags' => [
    'tag1',
    'tag2'
  ],
  'timeline' => [
    'firstOnline' => '2015-12-31',
    'publisherAcceptance' => '2015-12-31',
    'publisherPublication' => '2015-12-31'
  ],
  'title' => 'Test article title'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        'name' => 'John Doe'
    ],
    [
        'id' => 1000008
    ]
  ],
  'categories' => [
    1,
    10,
    11
  ],
  'categories_by_source_id' => [
    '300204',
    '400207'
  ],
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'defined_type' => 'media',
  'description' => 'Test description of article',
  'is_metadata_record' => null,
  'keywords' => [
    'tag1',
    'tag2'
  ],
  'license' => 1,
  'metadata_reason' => 'hosted somewhere else',
  'references' => [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  'tags' => [
    'tag1',
    'tag2'
  ],
  'timeline' => [
    'firstOnline' => '2015-12-31',
    'publisherAcceptance' => '2015-12-31',
    'publisherPublication' => '2015-12-31'
  ],
  'title' => 'Test article title'
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/versions/:version_id/');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/versions/:version_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/versions/:version_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/versions/:version_id/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/versions/:version_id/"

payload = {
    "authors": [{ "name": "John Doe" }, { "id": 1000008 }],
    "categories": [1, 10, 11],
    "categories_by_source_id": ["300204", "400207"],
    "custom_fields": { "defined_key": "value for it" },
    "defined_type": "media",
    "description": "Test description of article",
    "is_metadata_record": True,
    "keywords": ["tag1", "tag2"],
    "license": 1,
    "metadata_reason": "hosted somewhere else",
    "references": ["http://figshare.com", "http://api.figshare.com"],
    "tags": ["tag1", "tag2"],
    "timeline": {
        "firstOnline": "2015-12-31",
        "publisherAcceptance": "2015-12-31",
        "publisherPublication": "2015-12-31"
    },
    "title": "Test article title"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/versions/:version_id/"

payload <- "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/versions/:version_id/")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/versions/:version_id/') do |req|
  req.body = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/versions/:version_id/";

    let payload = json!({
        "authors": (json!({"name": "John Doe"}), json!({"id": 1000008})),
        "categories": (1, 10, 11),
        "categories_by_source_id": ("300204", "400207"),
        "custom_fields": json!({"defined_key": "value for it"}),
        "defined_type": "media",
        "description": "Test description of article",
        "is_metadata_record": true,
        "keywords": ("tag1", "tag2"),
        "license": 1,
        "metadata_reason": "hosted somewhere else",
        "references": ("http://figshare.com", "http://api.figshare.com"),
        "tags": ("tag1", "tag2"),
        "timeline": json!({
            "firstOnline": "2015-12-31",
            "publisherAcceptance": "2015-12-31",
            "publisherPublication": "2015-12-31"
        }),
        "title": "Test article title"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/versions/:version_id/ \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}'

echo '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/versions/:version_id/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {\n      "name": "John Doe"\n    },\n    {\n      "id": 1000008\n    }\n  ],\n  "categories": [\n    1,\n    10,\n    11\n  ],\n  "categories_by_source_id": [\n    "300204",\n    "400207"\n  ],\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "defined_type": "media",\n  "description": "Test description of article",\n  "is_metadata_record": true,\n  "keywords": [\n    "tag1",\n    "tag2"\n  ],\n  "license": 1,\n  "metadata_reason": "hosted somewhere else",\n  "references": [\n    "http://figshare.com",\n    "http://api.figshare.com"\n  ],\n  "tags": [\n    "tag1",\n    "tag2"\n  ],\n  "timeline": {\n    "firstOnline": "2015-12-31",\n    "publisherAcceptance": "2015-12-31",\n    "publisherPublication": "2015-12-31"\n  },\n  "title": "Test article title"\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/versions/:version_id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authors": [["name": "John Doe"], ["id": 1000008]],
  "categories": [1, 10, 11],
  "categories_by_source_id": ["300204", "400207"],
  "custom_fields": ["defined_key": "value for it"],
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": ["tag1", "tag2"],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": ["http://figshare.com", "http://api.figshare.com"],
  "tags": ["tag1", "tag2"],
  "timeline": [
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  ],
  "title": "Test article title"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/versions/:version_id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update article

{{baseUrl}}/account/articles/:article_id

BODY json

{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "is_metadata_record": false,
  "keywords": [],
  "license": 0,
  "metadata_reason": "",
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id" {:content-type :json
                                                                        :form-params {:authors [{:name "John Doe"} {:id 1000008}]
                                                                                      :categories [1 10 11]
                                                                                      :categories_by_source_id ["300204" "400207"]
                                                                                      :custom_fields {:defined_key "value for it"}
                                                                                      :defined_type "media"
                                                                                      :description "Test description of article"
                                                                                      :is_metadata_record true
                                                                                      :keywords ["tag1" "tag2"]
                                                                                      :license 1
                                                                                      :metadata_reason "hosted somewhere else"
                                                                                      :references ["http://figshare.com" "http://api.figshare.com"]
                                                                                      :tags ["tag1" "tag2"]
                                                                                      :timeline {:firstOnline "2015-12-31"
                                                                                                 :publisherAcceptance "2015-12-31"
                                                                                                 :publisherPublication "2015-12-31"}
                                                                                      :title "Test article title"}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id"),
    Content = new StringContent("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id"

	payload := strings.NewReader("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 760

{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {
      name: 'John Doe'
    },
    {
      id: 1000008
    }
  ],
  categories: [
    1,
    10,
    11
  ],
  categories_by_source_id: [
    '300204',
    '400207'
  ],
  custom_fields: {
    defined_key: 'value for it'
  },
  defined_type: 'media',
  description: 'Test description of article',
  is_metadata_record: true,
  keywords: [
    'tag1',
    'tag2'
  ],
  license: 1,
  metadata_reason: 'hosted somewhere else',
  references: [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  tags: [
    'tag1',
    'tag2'
  ],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test article title'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{name: 'John Doe'}, {id: 1000008}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    defined_type: 'media',
    description: 'Test description of article',
    is_metadata_record: true,
    keywords: ['tag1', 'tag2'],
    license: 1,
    metadata_reason: 'hosted somewhere else',
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test article title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"name":"John Doe"},{"id":1000008}],"categories":[1,10,11],"categories_by_source_id":["300204","400207"],"custom_fields":{"defined_key":"value for it"},"defined_type":"media","description":"Test description of article","is_metadata_record":true,"keywords":["tag1","tag2"],"license":1,"metadata_reason":"hosted somewhere else","references":["http://figshare.com","http://api.figshare.com"],"tags":["tag1","tag2"],"timeline":{"firstOnline":"2015-12-31","publisherAcceptance":"2015-12-31","publisherPublication":"2015-12-31"},"title":"Test article title"}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {\n      "name": "John Doe"\n    },\n    {\n      "id": 1000008\n    }\n  ],\n  "categories": [\n    1,\n    10,\n    11\n  ],\n  "categories_by_source_id": [\n    "300204",\n    "400207"\n  ],\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "defined_type": "media",\n  "description": "Test description of article",\n  "is_metadata_record": true,\n  "keywords": [\n    "tag1",\n    "tag2"\n  ],\n  "license": 1,\n  "metadata_reason": "hosted somewhere else",\n  "references": [\n    "http://figshare.com",\n    "http://api.figshare.com"\n  ],\n  "tags": [\n    "tag1",\n    "tag2"\n  ],\n  "timeline": {\n    "firstOnline": "2015-12-31",\n    "publisherAcceptance": "2015-12-31",\n    "publisherPublication": "2015-12-31"\n  },\n  "title": "Test article title"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  authors: [{name: 'John Doe'}, {id: 1000008}],
  categories: [1, 10, 11],
  categories_by_source_id: ['300204', '400207'],
  custom_fields: {defined_key: 'value for it'},
  defined_type: 'media',
  description: 'Test description of article',
  is_metadata_record: true,
  keywords: ['tag1', 'tag2'],
  license: 1,
  metadata_reason: 'hosted somewhere else',
  references: ['http://figshare.com', 'http://api.figshare.com'],
  tags: ['tag1', 'tag2'],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test article title'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id',
  headers: {'content-type': 'application/json'},
  body: {
    authors: [{name: 'John Doe'}, {id: 1000008}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    defined_type: 'media',
    description: 'Test description of article',
    is_metadata_record: true,
    keywords: ['tag1', 'tag2'],
    license: 1,
    metadata_reason: 'hosted somewhere else',
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test article title'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {
      name: 'John Doe'
    },
    {
      id: 1000008
    }
  ],
  categories: [
    1,
    10,
    11
  ],
  categories_by_source_id: [
    '300204',
    '400207'
  ],
  custom_fields: {
    defined_key: 'value for it'
  },
  defined_type: 'media',
  description: 'Test description of article',
  is_metadata_record: true,
  keywords: [
    'tag1',
    'tag2'
  ],
  license: 1,
  metadata_reason: 'hosted somewhere else',
  references: [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  tags: [
    'tag1',
    'tag2'
  ],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test article title'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{name: 'John Doe'}, {id: 1000008}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    defined_type: 'media',
    description: 'Test description of article',
    is_metadata_record: true,
    keywords: ['tag1', 'tag2'],
    license: 1,
    metadata_reason: 'hosted somewhere else',
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test article title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"name":"John Doe"},{"id":1000008}],"categories":[1,10,11],"categories_by_source_id":["300204","400207"],"custom_fields":{"defined_key":"value for it"},"defined_type":"media","description":"Test description of article","is_metadata_record":true,"keywords":["tag1","tag2"],"license":1,"metadata_reason":"hosted somewhere else","references":["http://figshare.com","http://api.figshare.com"],"tags":["tag1","tag2"],"timeline":{"firstOnline":"2015-12-31","publisherAcceptance":"2015-12-31","publisherPublication":"2015-12-31"},"title":"Test article title"}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{ @"name": @"John Doe" }, @{ @"id": @1000008 } ],
                              @"categories": @[ @1, @10, @11 ],
                              @"categories_by_source_id": @[ @"300204", @"400207" ],
                              @"custom_fields": @{ @"defined_key": @"value for it" },
                              @"defined_type": @"media",
                              @"description": @"Test description of article",
                              @"is_metadata_record": @YES,
                              @"keywords": @[ @"tag1", @"tag2" ],
                              @"license": @1,
                              @"metadata_reason": @"hosted somewhere else",
                              @"references": @[ @"http://figshare.com", @"http://api.figshare.com" ],
                              @"tags": @[ @"tag1", @"tag2" ],
                              @"timeline": @{ @"firstOnline": @"2015-12-31", @"publisherAcceptance": @"2015-12-31", @"publisherPublication": @"2015-12-31" },
                              @"title": @"Test article title" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                'name' => 'John Doe'
        ],
        [
                'id' => 1000008
        ]
    ],
    'categories' => [
        1,
        10,
        11
    ],
    'categories_by_source_id' => [
        '300204',
        '400207'
    ],
    'custom_fields' => [
        'defined_key' => 'value for it'
    ],
    'defined_type' => 'media',
    'description' => 'Test description of article',
    'is_metadata_record' => null,
    'keywords' => [
        'tag1',
        'tag2'
    ],
    'license' => 1,
    'metadata_reason' => 'hosted somewhere else',
    'references' => [
        'http://figshare.com',
        'http://api.figshare.com'
    ],
    'tags' => [
        'tag1',
        'tag2'
    ],
    'timeline' => [
        'firstOnline' => '2015-12-31',
        'publisherAcceptance' => '2015-12-31',
        'publisherPublication' => '2015-12-31'
    ],
    'title' => 'Test article title'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id', [
  'body' => '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        'name' => 'John Doe'
    ],
    [
        'id' => 1000008
    ]
  ],
  'categories' => [
    1,
    10,
    11
  ],
  'categories_by_source_id' => [
    '300204',
    '400207'
  ],
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'defined_type' => 'media',
  'description' => 'Test description of article',
  'is_metadata_record' => null,
  'keywords' => [
    'tag1',
    'tag2'
  ],
  'license' => 1,
  'metadata_reason' => 'hosted somewhere else',
  'references' => [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  'tags' => [
    'tag1',
    'tag2'
  ],
  'timeline' => [
    'firstOnline' => '2015-12-31',
    'publisherAcceptance' => '2015-12-31',
    'publisherPublication' => '2015-12-31'
  ],
  'title' => 'Test article title'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        'name' => 'John Doe'
    ],
    [
        'id' => 1000008
    ]
  ],
  'categories' => [
    1,
    10,
    11
  ],
  'categories_by_source_id' => [
    '300204',
    '400207'
  ],
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'defined_type' => 'media',
  'description' => 'Test description of article',
  'is_metadata_record' => null,
  'keywords' => [
    'tag1',
    'tag2'
  ],
  'license' => 1,
  'metadata_reason' => 'hosted somewhere else',
  'references' => [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  'tags' => [
    'tag1',
    'tag2'
  ],
  'timeline' => [
    'firstOnline' => '2015-12-31',
    'publisherAcceptance' => '2015-12-31',
    'publisherPublication' => '2015-12-31'
  ],
  'title' => 'Test article title'
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id"

payload = {
    "authors": [{ "name": "John Doe" }, { "id": 1000008 }],
    "categories": [1, 10, 11],
    "categories_by_source_id": ["300204", "400207"],
    "custom_fields": { "defined_key": "value for it" },
    "defined_type": "media",
    "description": "Test description of article",
    "is_metadata_record": True,
    "keywords": ["tag1", "tag2"],
    "license": 1,
    "metadata_reason": "hosted somewhere else",
    "references": ["http://figshare.com", "http://api.figshare.com"],
    "tags": ["tag1", "tag2"],
    "timeline": {
        "firstOnline": "2015-12-31",
        "publisherAcceptance": "2015-12-31",
        "publisherPublication": "2015-12-31"
    },
    "title": "Test article title"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id"

payload <- "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id') do |req|
  req.body = "{\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 1000008\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"defined_type\": \"media\",\n  \"description\": \"Test description of article\",\n  \"is_metadata_record\": true,\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"license\": 1,\n  \"metadata_reason\": \"hosted somewhere else\",\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test article title\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id";

    let payload = json!({
        "authors": (json!({"name": "John Doe"}), json!({"id": 1000008})),
        "categories": (1, 10, 11),
        "categories_by_source_id": ("300204", "400207"),
        "custom_fields": json!({"defined_key": "value for it"}),
        "defined_type": "media",
        "description": "Test description of article",
        "is_metadata_record": true,
        "keywords": ("tag1", "tag2"),
        "license": 1,
        "metadata_reason": "hosted somewhere else",
        "references": ("http://figshare.com", "http://api.figshare.com"),
        "tags": ("tag1", "tag2"),
        "timeline": json!({
            "firstOnline": "2015-12-31",
            "publisherAcceptance": "2015-12-31",
            "publisherPublication": "2015-12-31"
        }),
        "title": "Test article title"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}'

echo '{
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 1000008
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": [
    "tag1",
    "tag2"
  ],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test article title"
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {\n      "name": "John Doe"\n    },\n    {\n      "id": 1000008\n    }\n  ],\n  "categories": [\n    1,\n    10,\n    11\n  ],\n  "categories_by_source_id": [\n    "300204",\n    "400207"\n  ],\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "defined_type": "media",\n  "description": "Test description of article",\n  "is_metadata_record": true,\n  "keywords": [\n    "tag1",\n    "tag2"\n  ],\n  "license": 1,\n  "metadata_reason": "hosted somewhere else",\n  "references": [\n    "http://figshare.com",\n    "http://api.figshare.com"\n  ],\n  "tags": [\n    "tag1",\n    "tag2"\n  ],\n  "timeline": {\n    "firstOnline": "2015-12-31",\n    "publisherAcceptance": "2015-12-31",\n    "publisherPublication": "2015-12-31"\n  },\n  "title": "Test article title"\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authors": [["name": "John Doe"], ["id": 1000008]],
  "categories": [1, 10, 11],
  "categories_by_source_id": ["300204", "400207"],
  "custom_fields": ["defined_key": "value for it"],
  "defined_type": "media",
  "description": "Test description of article",
  "is_metadata_record": true,
  "keywords": ["tag1", "tag2"],
  "license": 1,
  "metadata_reason": "hosted somewhere else",
  "references": ["http://figshare.com", "http://api.figshare.com"],
  "tags": ["tag1", "tag2"],
  "timeline": [
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  ],
  "title": "Test article title"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update private link

{{baseUrl}}/account/articles/:article_id/private_links/:link_id

BODY json

{
  "expires_date": "",
  "read_only": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/articles/:article_id/private_links/:link_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/articles/:article_id/private_links/:link_id" {:content-type :json
                                                                                               :form-params {:expires_date "2018-02-22 22:22:22"
                                                                                                             :read_only true}})

require "http/client"

url = "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/articles/:article_id/private_links/:link_id"),
    Content = new StringContent("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/articles/:article_id/private_links/:link_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

	payload := strings.NewReader("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")

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

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

}

PUT /baseUrl/account/articles/:article_id/private_links/:link_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/articles/:article_id/private_links/:link_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .header("content-type", "application/json")
  .body("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
  .asString();

const data = JSON.stringify({
  expires_date: '2018-02-22 22:22:22',
  read_only: true
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/articles/:article_id/private_links/:link_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '2018-02-22 22:22:22', read_only: true}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/articles/:article_id/private_links/:link_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"2018-02-22 22:22:22","read_only":true}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expires_date": "2018-02-22 22:22:22",\n  "read_only": true\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/articles/:article_id/private_links/:link_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({expires_date: '2018-02-22 22:22:22', read_only: true}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id',
  headers: {'content-type': 'application/json'},
  body: {expires_date: '2018-02-22 22:22:22', read_only: true},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/articles/:article_id/private_links/:link_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  expires_date: '2018-02-22 22:22:22',
  read_only: true
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/articles/:article_id/private_links/:link_id',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '2018-02-22 22:22:22', read_only: true}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/articles/:article_id/private_links/:link_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"2018-02-22 22:22:22","read_only":true}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expires_date": @"2018-02-22 22:22:22",
                              @"read_only": @YES };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/articles/:article_id/private_links/:link_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/articles/:article_id/private_links/:link_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/articles/:article_id/private_links/:link_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'expires_date' => '2018-02-22 22:22:22',
    'read_only' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/articles/:article_id/private_links/:link_id', [
  'body' => '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/articles/:article_id/private_links/:link_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expires_date' => '2018-02-22 22:22:22',
  'read_only' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'expires_date' => '2018-02-22 22:22:22',
  'read_only' => null
]));
$request->setRequestUrl('{{baseUrl}}/account/articles/:article_id/private_links/:link_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/articles/:article_id/private_links/:link_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/articles/:article_id/private_links/:link_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/articles/:article_id/private_links/:link_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

payload = {
    "expires_date": "2018-02-22 22:22:22",
    "read_only": True
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/articles/:article_id/private_links/:link_id"

payload <- "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/articles/:article_id/private_links/:link_id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/articles/:article_id/private_links/:link_id') do |req|
  req.body = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/articles/:article_id/private_links/:link_id";

    let payload = json!({
        "expires_date": "2018-02-22 22:22:22",
        "read_only": true
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/articles/:article_id/private_links/:link_id \
  --header 'content-type: application/json' \
  --data '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}'

echo '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}' |  \
  http PUT {{baseUrl}}/account/articles/:article_id/private_links/:link_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "expires_date": "2018-02-22 22:22:22",\n  "read_only": true\n}' \
  --output-document \
  - {{baseUrl}}/account/articles/:article_id/private_links/:link_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/articles/:article_id/private_links/:link_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

GET View article details

{{baseUrl}}/articles/:article_id

QUERY PARAMS

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/articles/:article_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/articles/:article_id")

require "http/client"

url = "{{baseUrl}}/articles/:article_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/articles/:article_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/articles/:article_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/articles/:article_id"

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

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

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

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

}

GET /baseUrl/articles/:article_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/articles/:article_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/articles/:article_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/articles/:article_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/articles/:article_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/articles/:article_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/articles/:article_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/articles/:article_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/articles/:article_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/articles/:article_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/articles/:article_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/articles/:article_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/articles/:article_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/articles/:article_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/articles/:article_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/articles/:article_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/articles/:article_id');

echo $response->getBody();

setUrl('{{baseUrl}}/articles/:article_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/articles/:article_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/articles/:article_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/articles/:article_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/articles/:article_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/articles/:article_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/articles/:article_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/articles/:article_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/articles/:article_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/articles/:article_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/articles/:article_id

http GET {{baseUrl}}/articles/:article_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/articles/:article_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET Author details

{{baseUrl}}/account/authors/:author_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/authors/:author_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/authors/:author_id")

require "http/client"

url = "{{baseUrl}}/account/authors/:author_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/authors/:author_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/authors/:author_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/authors/:author_id"

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

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

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

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

}

GET /baseUrl/account/authors/:author_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/authors/:author_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/authors/:author_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/authors/:author_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/authors/:author_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/authors/:author_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/authors/:author_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/authors/:author_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/authors/:author_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/authors/:author_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/authors/:author_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/authors/:author_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/authors/:author_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/authors/:author_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/authors/:author_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/authors/:author_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/authors/:author_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/authors/:author_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/authors/:author_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/authors/:author_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/authors/:author_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/authors/:author_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/authors/:author_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/authors/:author_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/authors/:author_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/authors/:author_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/authors/:author_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/authors/:author_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/authors/:author_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/authors/:author_id

http GET {{baseUrl}}/account/authors/:author_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/authors/:author_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/authors/:author_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

POST Search Authors

{{baseUrl}}/account/authors/search

BODY json

{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/authors/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/authors/search" {:content-type :json
                                                                   :form-params {:group_id 0
                                                                                 :institution_id 0
                                                                                 :is_active false
                                                                                 :is_public false
                                                                                 :limit 0
                                                                                 :offset 0
                                                                                 :orcid ""
                                                                                 :order ""
                                                                                 :order_direction ""
                                                                                 :page 0
                                                                                 :page_size 0
                                                                                 :search_for ""}})

require "http/client"

url = "{{baseUrl}}/account/authors/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/authors/search"),
    Content = new StringContent("{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/authors/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/authors/search"

	payload := strings.NewReader("{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")

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

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

}

POST /baseUrl/account/authors/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 221

{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/authors/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/authors/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/authors/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/authors/search")
  .header("content-type", "application/json")
  .body("{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  group_id: 0,
  institution_id: 0,
  is_active: false,
  is_public: false,
  limit: 0,
  offset: 0,
  orcid: '',
  order: '',
  order_direction: '',
  page: 0,
  page_size: 0,
  search_for: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/authors/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/authors/search',
  headers: {'content-type': 'application/json'},
  data: {
    group_id: 0,
    institution_id: 0,
    is_active: false,
    is_public: false,
    limit: 0,
    offset: 0,
    orcid: '',
    order: '',
    order_direction: '',
    page: 0,
    page_size: 0,
    search_for: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/authors/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"group_id":0,"institution_id":0,"is_active":false,"is_public":false,"limit":0,"offset":0,"orcid":"","order":"","order_direction":"","page":0,"page_size":0,"search_for":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/authors/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "group_id": 0,\n  "institution_id": 0,\n  "is_active": false,\n  "is_public": false,\n  "limit": 0,\n  "offset": 0,\n  "orcid": "",\n  "order": "",\n  "order_direction": "",\n  "page": 0,\n  "page_size": 0,\n  "search_for": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/authors/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/authors/search',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  group_id: 0,
  institution_id: 0,
  is_active: false,
  is_public: false,
  limit: 0,
  offset: 0,
  orcid: '',
  order: '',
  order_direction: '',
  page: 0,
  page_size: 0,
  search_for: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/authors/search',
  headers: {'content-type': 'application/json'},
  body: {
    group_id: 0,
    institution_id: 0,
    is_active: false,
    is_public: false,
    limit: 0,
    offset: 0,
    orcid: '',
    order: '',
    order_direction: '',
    page: 0,
    page_size: 0,
    search_for: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/authors/search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  group_id: 0,
  institution_id: 0,
  is_active: false,
  is_public: false,
  limit: 0,
  offset: 0,
  orcid: '',
  order: '',
  order_direction: '',
  page: 0,
  page_size: 0,
  search_for: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/authors/search',
  headers: {'content-type': 'application/json'},
  data: {
    group_id: 0,
    institution_id: 0,
    is_active: false,
    is_public: false,
    limit: 0,
    offset: 0,
    orcid: '',
    order: '',
    order_direction: '',
    page: 0,
    page_size: 0,
    search_for: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/authors/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"group_id":0,"institution_id":0,"is_active":false,"is_public":false,"limit":0,"offset":0,"orcid":"","order":"","order_direction":"","page":0,"page_size":0,"search_for":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"group_id": @0,
                              @"institution_id": @0,
                              @"is_active": @NO,
                              @"is_public": @NO,
                              @"limit": @0,
                              @"offset": @0,
                              @"orcid": @"",
                              @"order": @"",
                              @"order_direction": @"",
                              @"page": @0,
                              @"page_size": @0,
                              @"search_for": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/authors/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/authors/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/authors/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'group_id' => 0,
    'institution_id' => 0,
    'is_active' => null,
    'is_public' => null,
    'limit' => 0,
    'offset' => 0,
    'orcid' => '',
    'order' => '',
    'order_direction' => '',
    'page' => 0,
    'page_size' => 0,
    'search_for' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/authors/search', [
  'body' => '{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/authors/search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'group_id' => 0,
  'institution_id' => 0,
  'is_active' => null,
  'is_public' => null,
  'limit' => 0,
  'offset' => 0,
  'orcid' => '',
  'order' => '',
  'order_direction' => '',
  'page' => 0,
  'page_size' => 0,
  'search_for' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'group_id' => 0,
  'institution_id' => 0,
  'is_active' => null,
  'is_public' => null,
  'limit' => 0,
  'offset' => 0,
  'orcid' => '',
  'order' => '',
  'order_direction' => '',
  'page' => 0,
  'page_size' => 0,
  'search_for' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/authors/search');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/authors/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/authors/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/authors/search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/authors/search"

payload = {
    "group_id": 0,
    "institution_id": 0,
    "is_active": False,
    "is_public": False,
    "limit": 0,
    "offset": 0,
    "orcid": "",
    "order": "",
    "order_direction": "",
    "page": 0,
    "page_size": 0,
    "search_for": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/authors/search"

payload <- "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/authors/search")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/authors/search') do |req|
  req.body = "{\n  \"group_id\": 0,\n  \"institution_id\": 0,\n  \"is_active\": false,\n  \"is_public\": false,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"orcid\": \"\",\n  \"order\": \"\",\n  \"order_direction\": \"\",\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/authors/search";

    let payload = json!({
        "group_id": 0,
        "institution_id": 0,
        "is_active": false,
        "is_public": false,
        "limit": 0,
        "offset": 0,
        "orcid": "",
        "order": "",
        "order_direction": "",
        "page": 0,
        "page_size": 0,
        "search_for": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/authors/search \
  --header 'content-type: application/json' \
  --data '{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}'

echo '{
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
}' |  \
  http POST {{baseUrl}}/account/authors/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "group_id": 0,\n  "institution_id": 0,\n  "is_active": false,\n  "is_public": false,\n  "limit": 0,\n  "offset": 0,\n  "orcid": "",\n  "order": "",\n  "order_direction": "",\n  "page": 0,\n  "page_size": 0,\n  "search_for": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/authors/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "group_id": 0,
  "institution_id": 0,
  "is_active": false,
  "is_public": false,
  "limit": 0,
  "offset": 0,
  "orcid": "",
  "order": "",
  "order_direction": "",
  "page": 0,
  "page_size": 0,
  "search_for": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/authors/search")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "full_name": "John Doe",
    "id": 97657,
    "is_active": 1,
    "orcid_id": "1234-5678-9123-1234",
    "url_name": "John_Doe"
  }
]

POST Add collection articles

{{baseUrl}}/account/collections/:collection_id/articles

BODY json

{
  "articles": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/articles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/articles" {:content-type :json
                                                                                        :form-params {:articles [2000003 2000004]}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/articles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/articles"),
    Content = new StringContent("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/articles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/articles"

	payload := strings.NewReader("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")

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

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

}

POST /baseUrl/account/collections/:collection_id/articles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "articles": [
    2000003,
    2000004
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/articles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/articles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/articles")
  .header("content-type", "application/json")
  .body("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
  .asString();

const data = JSON.stringify({
  articles: [
    2000003,
    2000004
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/articles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  headers: {'content-type': 'application/json'},
  data: {articles: [2000003, 2000004]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/articles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[2000003,2000004]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "articles": [\n    2000003,\n    2000004\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/articles',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({articles: [2000003, 2000004]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  headers: {'content-type': 'application/json'},
  body: {articles: [2000003, 2000004]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/articles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  articles: [
    2000003,
    2000004
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  headers: {'content-type': 'application/json'},
  data: {articles: [2000003, 2000004]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/articles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[2000003,2000004]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"articles": @[ @2000003, @2000004 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/articles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'articles' => [
        2000003,
        2000004
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/articles', [
  'body' => '{
  "articles": [
    2000003,
    2000004
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/articles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'articles' => [
    2000003,
    2000004
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'articles' => [
    2000003,
    2000004
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/articles');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/articles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [
    2000003,
    2000004
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/articles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [
    2000003,
    2000004
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections/:collection_id/articles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/articles"

payload = { "articles": [2000003, 2000004] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/articles"

payload <- "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/articles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections/:collection_id/articles') do |req|
  req.body = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/articles";

    let payload = json!({"articles": (2000003, 2000004)});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/articles \
  --header 'content-type: application/json' \
  --data '{
  "articles": [
    2000003,
    2000004
  ]
}'

echo '{
  "articles": [
    2000003,
    2000004
  ]
}' |  \
  http POST {{baseUrl}}/account/collections/:collection_id/articles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "articles": [\n    2000003,\n    2000004\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/articles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["articles": [2000003, 2000004]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/articles")! 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()

POST Add collection authors

{{baseUrl}}/account/collections/:collection_id/authors

BODY json

{
  "authors": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/authors");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/authors" {:content-type :json
                                                                                       :form-params {:authors [{:id 12121} {:id 34345} {:name "John Doe"}]}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/authors"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/authors"),
    Content = new StringContent("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/authors");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/authors"

	payload := strings.NewReader("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")

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

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

}

POST /baseUrl/account/collections/:collection_id/authors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 121

{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/authors")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/authors"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/authors")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/authors');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/authors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/authors',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  headers: {'content-type': 'application/json'},
  body: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/authors');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/authors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{ @"id": @12121 }, @{ @"id": @34345 }, @{ @"name": @"John Doe" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/authors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/authors" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/authors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                'id' => 12121
        ],
        [
                'id' => 34345
        ],
        [
                'name' => 'John Doe'
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/authors', [
  'body' => '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/authors');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/authors');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/authors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/authors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections/:collection_id/authors", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/authors"

payload = { "authors": [{ "id": 12121 }, { "id": 34345 }, { "name": "John Doe" }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/authors"

payload <- "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/authors")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections/:collection_id/authors') do |req|
  req.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/authors";

    let payload = json!({"authors": (json!({"id": 12121}), json!({"id": 34345}), json!({"name": "John Doe"}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/authors \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

echo '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}' |  \
  http POST {{baseUrl}}/account/collections/:collection_id/authors \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/authors

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["authors": [["id": 12121], ["id": 34345], ["name": "John Doe"]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/authors")! 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()

POST Add collection categories

{{baseUrl}}/account/collections/:collection_id/categories

BODY json

{
  "categories": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/categories" {:content-type :json
                                                                                          :form-params {:categories [1 10 11]}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/categories"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/categories"),
    Content = new StringContent("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/categories");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/categories"

	payload := strings.NewReader("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")

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

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

}

POST /baseUrl/account/collections/:collection_id/categories HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "categories": [
    1,
    10,
    11
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/categories")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/categories"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/categories")
  .header("content-type", "application/json")
  .body("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .asString();

const data = JSON.stringify({
  categories: [
    1,
    10,
    11
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/categories');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/categories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/categories',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({categories: [1, 10, 11]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  headers: {'content-type': 'application/json'},
  body: {categories: [1, 10, 11]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/categories');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  categories: [
    1,
    10,
    11
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/categories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"categories": @[ @1, @10, @11 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/categories" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'categories' => [
        1,
        10,
        11
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/categories', [
  'body' => '{
  "categories": [
    1,
    10,
    11
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/categories');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/categories');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/categories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/categories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections/:collection_id/categories", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/categories"

payload = { "categories": [1, 10, 11] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/categories"

payload <- "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/categories")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections/:collection_id/categories') do |req|
  req.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/categories";

    let payload = json!({"categories": (1, 10, 11)});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/categories \
  --header 'content-type: application/json' \
  --data '{
  "categories": [
    1,
    10,
    11
  ]
}'

echo '{
  "categories": [
    1,
    10,
    11
  ]
}' |  \
  http POST {{baseUrl}}/account/collections/:collection_id/categories \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/categories

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["categories": [1, 10, 11]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/categories")! 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()

GET Collection Version details

{{baseUrl}}/collections/:collection_id/versions/:version_id

QUERY PARAMS

collection_id

version_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection_id/versions/:version_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/collections/:collection_id/versions/:version_id")

require "http/client"

url = "{{baseUrl}}/collections/:collection_id/versions/:version_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/collections/:collection_id/versions/:version_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/collections/:collection_id/versions/:version_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/collections/:collection_id/versions/:version_id"

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

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

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

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

}

GET /baseUrl/collections/:collection_id/versions/:version_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:collection_id/versions/:version_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/collections/:collection_id/versions/:version_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id/versions/:version_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/collections/:collection_id/versions/:version_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/collections/:collection_id/versions/:version_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/versions/:version_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/collections/:collection_id/versions/:version_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/collections/:collection_id/versions/:version_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id/versions/:version_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/collections/:collection_id/versions/:version_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/versions/:version_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/collections/:collection_id/versions/:version_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/versions/:version_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/collections/:collection_id/versions/:version_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/:collection_id/versions/:version_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/collections/:collection_id/versions/:version_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/collections/:collection_id/versions/:version_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/collections/:collection_id/versions/:version_id');

echo $response->getBody();

setUrl('{{baseUrl}}/collections/:collection_id/versions/:version_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/collections/:collection_id/versions/:version_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection_id/versions/:version_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection_id/versions/:version_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/collections/:collection_id/versions/:version_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/collections/:collection_id/versions/:version_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/collections/:collection_id/versions/:version_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/collections/:collection_id/versions/:version_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/collections/:collection_id/versions/:version_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/collections/:collection_id/versions/:version_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/collections/:collection_id/versions/:version_id

http GET {{baseUrl}}/collections/:collection_id/versions/:version_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/collections/:collection_id/versions/:version_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection_id/versions/:version_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET Collection Versions list

{{baseUrl}}/collections/:collection_id/versions

QUERY PARAMS

collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection_id/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/collections/:collection_id/versions")

require "http/client"

url = "{{baseUrl}}/collections/:collection_id/versions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/collections/:collection_id/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/collections/:collection_id/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/collections/:collection_id/versions"

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

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

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

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

}

GET /baseUrl/collections/:collection_id/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:collection_id/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/collections/:collection_id/versions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/collections/:collection_id/versions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/collections/:collection_id/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/collections/:collection_id/versions';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/collections/:collection_id/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/collections/:collection_id/versions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/versions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/collections/:collection_id/versions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/collections/:collection_id/versions';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/:collection_id/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/collections/:collection_id/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/collections/:collection_id/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/collections/:collection_id/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/collections/:collection_id/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/collections/:collection_id/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection_id/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection_id/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/collections/:collection_id/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/collections/:collection_id/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/collections/:collection_id/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/collections/:collection_id/versions")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/collections/:collection_id/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/collections/:collection_id/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/collections/:collection_id/versions

http GET {{baseUrl}}/collections/:collection_id/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/collections/:collection_id/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection_id/versions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET Collection details (GET)

{{baseUrl}}/collections/:collection_id

QUERY PARAMS

collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/collections/:collection_id")

require "http/client"

url = "{{baseUrl}}/collections/:collection_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/collections/:collection_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/collections/:collection_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/collections/:collection_id"

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

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

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

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

}

GET /baseUrl/collections/:collection_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:collection_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/collections/:collection_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/collections/:collection_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/collections/:collection_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/collections/:collection_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/collections/:collection_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/collections/:collection_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/collections/:collection_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/collections/:collection_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/collections/:collection_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/collections/:collection_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/collections/:collection_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/:collection_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/collections/:collection_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/collections/:collection_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/collections/:collection_id');

echo $response->getBody();

setUrl('{{baseUrl}}/collections/:collection_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/collections/:collection_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/collections/:collection_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/collections/:collection_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/collections/:collection_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/collections/:collection_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/collections/:collection_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/collections/:collection_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/collections/:collection_id

http GET {{baseUrl}}/collections/:collection_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/collections/:collection_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

GET Collection details

{{baseUrl}}/account/collections/:collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/collections/:collection_id")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id"

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

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

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

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

}

GET /baseUrl/account/collections/:collection_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/collections/:collection_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/collections/:collection_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/collections/:collection_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/collections/:collection_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/collections/:collection_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/collections/:collection_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/collections/:collection_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/collections/:collection_id

http GET {{baseUrl}}/account/collections/:collection_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "account_id": 1000001,
  "articles_count": 1,
  "citation": "citation",
  "created_date": "2017-05-15T15:12:26Z",
  "description": "description",
  "group_id": 1,
  "group_resource_id": 1,
  "institution_id": 1,
  "modified_date": "2017-05-15T15:12:26Z",
  "public": true,
  "resource_doi": "10.6084/m9.figshare.123",
  "resource_id": "",
  "resource_link": "http://figshare.com",
  "resource_title": "test",
  "resource_version": 0,
  "tags": [
    "t1",
    "t2"
  ],
  "timeline": {
    "posted": "2015-12-31",
    "revision": "2015-12-31",
    "submission": "2015-12-31"
  },
  "version": 1
}

POST Create collection private link

{{baseUrl}}/account/collections/:collection_id/private_links

BODY json

{
  "expires_date": "",
  "read_only": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/private_links");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/private_links" {:content-type :json
                                                                                             :form-params {:expires_date ""
                                                                                                           :read_only false}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/private_links"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/private_links"),
    Content = new StringContent("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/private_links");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/private_links"

	payload := strings.NewReader("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")

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

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

}

POST /baseUrl/account/collections/:collection_id/private_links HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "expires_date": "",
  "read_only": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/private_links")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/private_links"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/private_links")
  .header("content-type", "application/json")
  .body("{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
  .asString();

const data = JSON.stringify({
  expires_date: '',
  read_only: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/private_links');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '', read_only: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/private_links';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"","read_only":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/private_links',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expires_date": "",\n  "read_only": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/private_links',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({expires_date: '', read_only: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links',
  headers: {'content-type': 'application/json'},
  body: {expires_date: '', read_only: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/private_links');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  expires_date: '',
  read_only: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '', read_only: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/private_links';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"","read_only":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expires_date": @"",
                              @"read_only": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/private_links"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/private_links" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/private_links",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'expires_date' => '',
    'read_only' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/private_links', [
  'body' => '{
  "expires_date": "",
  "read_only": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/private_links');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expires_date' => '',
  'read_only' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'expires_date' => '',
  'read_only' => null
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/private_links');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/private_links' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "",
  "read_only": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/private_links' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "",
  "read_only": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections/:collection_id/private_links", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/private_links"

payload = {
    "expires_date": "",
    "read_only": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/private_links"

payload <- "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/private_links")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections/:collection_id/private_links') do |req|
  req.body = "{\n  \"expires_date\": \"\",\n  \"read_only\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/private_links";

    let payload = json!({
        "expires_date": "",
        "read_only": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/private_links \
  --header 'content-type: application/json' \
  --data '{
  "expires_date": "",
  "read_only": false
}'

echo '{
  "expires_date": "",
  "read_only": false
}' |  \
  http POST {{baseUrl}}/account/collections/:collection_id/private_links \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "expires_date": "",\n  "read_only": false\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/private_links

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "expires_date": "",
  "read_only": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/private_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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "html_location": "https://figshare.com/s/d5ec7a85bcd6dbe9d9b2",
  "token": "d5ec7a85bcd6dbe9d9b2"
}

POST Create collection

{{baseUrl}}/account/collections

BODY json

{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections" {:content-type :json
                                                                :form-params {:articles []
                                                                              :authors [{}]
                                                                              :categories []
                                                                              :categories_by_source_id []
                                                                              :custom_fields {}
                                                                              :custom_fields_list [{:name ""
                                                                                                    :value ""}]
                                                                              :description ""
                                                                              :doi ""
                                                                              :funding ""
                                                                              :funding_list [{:id 0
                                                                                              :title ""}]
                                                                              :group_id 0
                                                                              :handle ""
                                                                              :keywords []
                                                                              :references []
                                                                              :resource_doi ""
                                                                              :resource_id ""
                                                                              :resource_link ""
                                                                              :resource_title ""
                                                                              :resource_version 0
                                                                              :tags []
                                                                              :timeline {:firstOnline ""
                                                                                         :publisherAcceptance ""
                                                                                         :publisherPublication ""}
                                                                              :title ""}})

require "http/client"

url = "{{baseUrl}}/account/collections"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections"),
    Content = new StringContent("{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections"

	payload := strings.NewReader("{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")

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

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

}

POST /baseUrl/account/collections HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 644

{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections")
  .header("content-type", "application/json")
  .body("{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  articles: [],
  authors: [
    {}
  ],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  description: '',
  doi: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  group_id: 0,
  handle: '',
  keywords: [],
  references: [],
  resource_doi: '',
  resource_id: '',
  resource_link: '',
  resource_title: '',
  resource_version: 0,
  tags: [],
  timeline: {
    firstOnline: '',
    publisherAcceptance: '',
    publisherPublication: ''
  },
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections',
  headers: {'content-type': 'application/json'},
  data: {
    articles: [],
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    handle: '',
    keywords: [],
    references: [],
    resource_doi: '',
    resource_id: '',
    resource_link: '',
    resource_title: '',
    resource_version: 0,
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[],"authors":[{}],"categories":[],"categories_by_source_id":[],"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"description":"","doi":"","funding":"","funding_list":[{"id":0,"title":""}],"group_id":0,"handle":"","keywords":[],"references":[],"resource_doi":"","resource_id":"","resource_link":"","resource_title":"","resource_version":0,"tags":[],"timeline":{"firstOnline":"","publisherAcceptance":"","publisherPublication":""},"title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "articles": [],\n  "authors": [\n    {}\n  ],\n  "categories": [],\n  "categories_by_source_id": [],\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "description": "",\n  "doi": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "group_id": 0,\n  "handle": "",\n  "keywords": [],\n  "references": [],\n  "resource_doi": "",\n  "resource_id": "",\n  "resource_link": "",\n  "resource_title": "",\n  "resource_version": 0,\n  "tags": [],\n  "timeline": {\n    "firstOnline": "",\n    "publisherAcceptance": "",\n    "publisherPublication": ""\n  },\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  articles: [],
  authors: [{}],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [{name: '', value: ''}],
  description: '',
  doi: '',
  funding: '',
  funding_list: [{id: 0, title: ''}],
  group_id: 0,
  handle: '',
  keywords: [],
  references: [],
  resource_doi: '',
  resource_id: '',
  resource_link: '',
  resource_title: '',
  resource_version: 0,
  tags: [],
  timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections',
  headers: {'content-type': 'application/json'},
  body: {
    articles: [],
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    handle: '',
    keywords: [],
    references: [],
    resource_doi: '',
    resource_id: '',
    resource_link: '',
    resource_title: '',
    resource_version: 0,
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  articles: [],
  authors: [
    {}
  ],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  description: '',
  doi: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  group_id: 0,
  handle: '',
  keywords: [],
  references: [],
  resource_doi: '',
  resource_id: '',
  resource_link: '',
  resource_title: '',
  resource_version: 0,
  tags: [],
  timeline: {
    firstOnline: '',
    publisherAcceptance: '',
    publisherPublication: ''
  },
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections',
  headers: {'content-type': 'application/json'},
  data: {
    articles: [],
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    handle: '',
    keywords: [],
    references: [],
    resource_doi: '',
    resource_id: '',
    resource_link: '',
    resource_title: '',
    resource_version: 0,
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[],"authors":[{}],"categories":[],"categories_by_source_id":[],"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"description":"","doi":"","funding":"","funding_list":[{"id":0,"title":""}],"group_id":0,"handle":"","keywords":[],"references":[],"resource_doi":"","resource_id":"","resource_link":"","resource_title":"","resource_version":0,"tags":[],"timeline":{"firstOnline":"","publisherAcceptance":"","publisherPublication":""},"title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"articles": @[  ],
                              @"authors": @[ @{  } ],
                              @"categories": @[  ],
                              @"categories_by_source_id": @[  ],
                              @"custom_fields": @{  },
                              @"custom_fields_list": @[ @{ @"name": @"", @"value": @"" } ],
                              @"description": @"",
                              @"doi": @"",
                              @"funding": @"",
                              @"funding_list": @[ @{ @"id": @0, @"title": @"" } ],
                              @"group_id": @0,
                              @"handle": @"",
                              @"keywords": @[  ],
                              @"references": @[  ],
                              @"resource_doi": @"",
                              @"resource_id": @"",
                              @"resource_link": @"",
                              @"resource_title": @"",
                              @"resource_version": @0,
                              @"tags": @[  ],
                              @"timeline": @{ @"firstOnline": @"", @"publisherAcceptance": @"", @"publisherPublication": @"" },
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'articles' => [
        
    ],
    'authors' => [
        [
                
        ]
    ],
    'categories' => [
        
    ],
    'categories_by_source_id' => [
        
    ],
    'custom_fields' => [
        
    ],
    'custom_fields_list' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'description' => '',
    'doi' => '',
    'funding' => '',
    'funding_list' => [
        [
                'id' => 0,
                'title' => ''
        ]
    ],
    'group_id' => 0,
    'handle' => '',
    'keywords' => [
        
    ],
    'references' => [
        
    ],
    'resource_doi' => '',
    'resource_id' => '',
    'resource_link' => '',
    'resource_title' => '',
    'resource_version' => 0,
    'tags' => [
        
    ],
    'timeline' => [
        'firstOnline' => '',
        'publisherAcceptance' => '',
        'publisherPublication' => ''
    ],
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections', [
  'body' => '{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'articles' => [
    
  ],
  'authors' => [
    [
        
    ]
  ],
  'categories' => [
    
  ],
  'categories_by_source_id' => [
    
  ],
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'description' => '',
  'doi' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'group_id' => 0,
  'handle' => '',
  'keywords' => [
    
  ],
  'references' => [
    
  ],
  'resource_doi' => '',
  'resource_id' => '',
  'resource_link' => '',
  'resource_title' => '',
  'resource_version' => 0,
  'tags' => [
    
  ],
  'timeline' => [
    'firstOnline' => '',
    'publisherAcceptance' => '',
    'publisherPublication' => ''
  ],
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'articles' => [
    
  ],
  'authors' => [
    [
        
    ]
  ],
  'categories' => [
    
  ],
  'categories_by_source_id' => [
    
  ],
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'description' => '',
  'doi' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'group_id' => 0,
  'handle' => '',
  'keywords' => [
    
  ],
  'references' => [
    
  ],
  'resource_doi' => '',
  'resource_id' => '',
  'resource_link' => '',
  'resource_title' => '',
  'resource_version' => 0,
  'tags' => [
    
  ],
  'timeline' => [
    'firstOnline' => '',
    'publisherAcceptance' => '',
    'publisherPublication' => ''
  ],
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/collections');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections"

payload = {
    "articles": [],
    "authors": [{}],
    "categories": [],
    "categories_by_source_id": [],
    "custom_fields": {},
    "custom_fields_list": [
        {
            "name": "",
            "value": ""
        }
    ],
    "description": "",
    "doi": "",
    "funding": "",
    "funding_list": [
        {
            "id": 0,
            "title": ""
        }
    ],
    "group_id": 0,
    "handle": "",
    "keywords": [],
    "references": [],
    "resource_doi": "",
    "resource_id": "",
    "resource_link": "",
    "resource_title": "",
    "resource_version": 0,
    "tags": [],
    "timeline": {
        "firstOnline": "",
        "publisherAcceptance": "",
        "publisherPublication": ""
    },
    "title": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections"

payload <- "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections') do |req|
  req.body = "{\n  \"articles\": [],\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_id\": \"\",\n  \"resource_link\": \"\",\n  \"resource_title\": \"\",\n  \"resource_version\": 0,\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections";

    let payload = json!({
        "articles": (),
        "authors": (json!({})),
        "categories": (),
        "categories_by_source_id": (),
        "custom_fields": json!({}),
        "custom_fields_list": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "description": "",
        "doi": "",
        "funding": "",
        "funding_list": (
            json!({
                "id": 0,
                "title": ""
            })
        ),
        "group_id": 0,
        "handle": "",
        "keywords": (),
        "references": (),
        "resource_doi": "",
        "resource_id": "",
        "resource_link": "",
        "resource_title": "",
        "resource_version": 0,
        "tags": (),
        "timeline": json!({
            "firstOnline": "",
            "publisherAcceptance": "",
            "publisherPublication": ""
        }),
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections \
  --header 'content-type: application/json' \
  --data '{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

echo '{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}' |  \
  http POST {{baseUrl}}/account/collections \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "articles": [],\n  "authors": [\n    {}\n  ],\n  "categories": [],\n  "categories_by_source_id": [],\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "description": "",\n  "doi": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "group_id": 0,\n  "handle": "",\n  "keywords": [],\n  "references": [],\n  "resource_doi": "",\n  "resource_id": "",\n  "resource_link": "",\n  "resource_title": "",\n  "resource_version": 0,\n  "tags": [],\n  "timeline": {\n    "firstOnline": "",\n    "publisherAcceptance": "",\n    "publisherPublication": ""\n  },\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/collections

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "articles": [],
  "authors": [[]],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": [],
  "custom_fields_list": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    [
      "id": 0,
      "title": ""
    ]
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": [
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  ],
  "title": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "entity_id": 33334444
}

DELETE Delete collection article

{{baseUrl}}/account/collections/:collection_id/articles/:article_id

QUERY PARAMS

collection_id

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/articles/:article_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/collections/:collection_id/articles/:article_id")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/articles/:article_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/articles/:article_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/articles/:article_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/articles/:article_id"

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

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

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

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

}

DELETE /baseUrl/account/collections/:collection_id/articles/:article_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/collections/:collection_id/articles/:article_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/articles/:article_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles/:article_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/collections/:collection_id/articles/:article_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/collections/:collection_id/articles/:article_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/articles/:article_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/articles/:article_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles/:article_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/articles/:article_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/articles/:article_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/collections/:collection_id/articles/:article_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/articles/:article_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/articles/:article_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/collections/:collection_id/articles/:article_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/articles/:article_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/articles/:article_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/articles/:article_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/articles/:article_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/collections/:collection_id/articles/:article_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/articles/:article_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/articles/:article_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/articles/:article_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/collections/:collection_id/articles/:article_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/articles/:article_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/collections/:collection_id/articles/:article_id

http DELETE {{baseUrl}}/account/collections/:collection_id/articles/:article_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/articles/:article_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete collection author

{{baseUrl}}/account/collections/:collection_id/authors/:author_id

QUERY PARAMS

collection_id

author_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/authors/:author_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/collections/:collection_id/authors/:author_id")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/authors/:author_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/authors/:author_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/authors/:author_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/authors/:author_id"

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

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

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

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

}

DELETE /baseUrl/account/collections/:collection_id/authors/:author_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/collections/:collection_id/authors/:author_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/authors/:author_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors/:author_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/collections/:collection_id/authors/:author_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/collections/:collection_id/authors/:author_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/authors/:author_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/authors/:author_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/authors/:author_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors/:author_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/authors/:author_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/authors/:author_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/collections/:collection_id/authors/:author_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/authors/:author_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/authors/:author_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/authors/:author_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/authors/:author_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/authors/:author_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/collections/:collection_id/authors/:author_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/authors/:author_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/authors/:author_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/authors/:author_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/authors/:author_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/collections/:collection_id/authors/:author_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/authors/:author_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/authors/:author_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/authors/:author_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/collections/:collection_id/authors/:author_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/authors/:author_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/collections/:collection_id/authors/:author_id

http DELETE {{baseUrl}}/account/collections/:collection_id/authors/:author_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/authors/:author_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/authors/:author_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete collection category

{{baseUrl}}/account/collections/:collection_id/categories/:category_id

QUERY PARAMS

collection_id

category_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/categories/:category_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/collections/:collection_id/categories/:category_id")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/categories/:category_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/categories/:category_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/categories/:category_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/categories/:category_id"

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

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

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

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

}

DELETE /baseUrl/account/collections/:collection_id/categories/:category_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/collections/:collection_id/categories/:category_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/categories/:category_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories/:category_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/collections/:collection_id/categories/:category_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/collections/:collection_id/categories/:category_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/categories/:category_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/categories/:category_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/categories/:category_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories/:category_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/categories/:category_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/categories/:category_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/collections/:collection_id/categories/:category_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/categories/:category_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/categories/:category_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/categories/:category_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/categories/:category_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/categories/:category_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/collections/:collection_id/categories/:category_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/categories/:category_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/categories/:category_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/categories/:category_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/categories/:category_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/collections/:collection_id/categories/:category_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/categories/:category_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/categories/:category_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/categories/:category_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/collections/:collection_id/categories/:category_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/categories/:category_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/collections/:collection_id/categories/:category_id

http DELETE {{baseUrl}}/account/collections/:collection_id/categories/:category_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/categories/:category_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/categories/:category_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Delete collection

{{baseUrl}}/account/collections/:collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/collections/:collection_id")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id"

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

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

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

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

}

DELETE /baseUrl/account/collections/:collection_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/collections/:collection_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/collections/:collection_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/collections/:collection_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/collections/:collection_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/collections/:collection_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/collections/:collection_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/collections/:collection_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/collections/:collection_id

http DELETE {{baseUrl}}/account/collections/:collection_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

DELETE Disable private link (DELETE)

{{baseUrl}}/account/collections/:collection_id/private_links/:link_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

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

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

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

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

}

DELETE /baseUrl/account/collections/:collection_id/private_links/:link_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/private_links/:link_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/collections/:collection_id/private_links/:link_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/collections/:collection_id/private_links/:link_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/collections/:collection_id/private_links/:link_id

http DELETE {{baseUrl}}/account/collections/:collection_id/private_links/:link_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/private_links/:link_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

GET List collection articles

{{baseUrl}}/account/collections/:collection_id/articles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/collections/:collection_id/articles")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/articles"

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

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

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

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

}

GET /baseUrl/account/collections/:collection_id/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/collections/:collection_id/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/collections/:collection_id/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/collections/:collection_id/articles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/articles';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/articles'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/collections/:collection_id/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/articles';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/collections/:collection_id/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/collections/:collection_id/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/articles")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/collections/:collection_id/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/collections/:collection_id/articles

http GET {{baseUrl}}/account/collections/:collection_id/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "defined_type": 3,
    "defined_type_name": "media",
    "doi": "10.6084/m9.figshare.1434614",
    "group_id": 1234,
    "handle": "111184/figshare.1234",
    "id": 1434614,
    "published_date": "2015-12-31T23:59:59.000Z",
    "thumb": "https://ndownloader.figshare.com/files/123456789/preview/12345678/thumb.png",
    "title": "Test article title",
    "url": "http://api.figshare.com/articles/1434614",
    "url_private_api": "https://api.figshare.com/account/articles/1434614",
    "url_private_html": "https://figshare.com/account/articles/1434614",
    "url_public_api": "https://api.figshare.com/articles/1434614",
    "url_public_html": "https://figshare.com/articles/media/Test_article_title/1434614"
  }
]

GET List collection authors

{{baseUrl}}/account/collections/:collection_id/authors

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/authors");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/collections/:collection_id/authors")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/authors"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/authors"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/authors");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/authors"

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

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

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

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

}

GET /baseUrl/account/collections/:collection_id/authors HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/collections/:collection_id/authors")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/authors"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/collections/:collection_id/authors")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/collections/:collection_id/authors');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/authors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/authors';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/authors',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/authors'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/collections/:collection_id/authors');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/authors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/authors';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/authors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/authors" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/authors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/collections/:collection_id/authors');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/authors');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/authors');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/authors' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/authors' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/collections/:collection_id/authors")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/authors"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/authors"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/authors")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/collections/:collection_id/authors') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/authors";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/collections/:collection_id/authors

http GET {{baseUrl}}/account/collections/:collection_id/authors

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/authors

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/authors")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "full_name": "John Doe",
    "id": 97657,
    "is_active": 1,
    "orcid_id": "1234-5678-9123-1234",
    "url_name": "John_Doe"
  }
]

GET List collection categories

{{baseUrl}}/account/collections/:collection_id/categories

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/collections/:collection_id/categories")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/categories"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/categories"

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

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

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

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

}

GET /baseUrl/account/collections/:collection_id/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/collections/:collection_id/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/collections/:collection_id/categories")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/collections/:collection_id/categories');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/categories';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/categories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/categories'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/collections/:collection_id/categories');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/categories';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/collections/:collection_id/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/categories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/categories' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/collections/:collection_id/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/categories")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/collections/:collection_id/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/collections/:collection_id/categories

http GET {{baseUrl}}/account/collections/:collection_id/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": 11,
    "parent_id": 1,
    "path": "/450/1024/6532",
    "source_id": "300204",
    "taxonomy_id": 4,
    "title": "Anatomy"
  }
]

GET List collection private links

{{baseUrl}}/account/collections/:collection_id/private_links

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/private_links");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/collections/:collection_id/private_links")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/private_links"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/private_links"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/private_links");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/private_links"

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

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

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

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

}

GET /baseUrl/account/collections/:collection_id/private_links HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/collections/:collection_id/private_links")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/private_links"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/collections/:collection_id/private_links")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/collections/:collection_id/private_links');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/private_links';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/private_links',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/private_links',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/collections/:collection_id/private_links');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/private_links';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/private_links"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/private_links" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/private_links",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/collections/:collection_id/private_links');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/private_links');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/private_links');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/private_links' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/private_links' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/collections/:collection_id/private_links")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/private_links"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/private_links"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/private_links")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/collections/:collection_id/private_links') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/private_links";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/collections/:collection_id/private_links

http GET {{baseUrl}}/account/collections/:collection_id/private_links

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/private_links

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/private_links")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "expires_date": "2015-07-03T00:00:00",
    "html_location": "https://figshare.com/s/d5ec7a85bcd6dbe9d9b2",
    "id": "0cfb0dbeac92df445df4aba45f63fdc85fa0b9a888b64e157ce3c93b576aa300fb3621ef3a219515dd482",
    "is_active": true
  }
]

POST Private Collection Publish

{{baseUrl}}/account/collections/:collection_id/publish

QUERY PARAMS

collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/publish");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/publish")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/publish"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/publish"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/publish"

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

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

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

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

}

POST /baseUrl/account/collections/:collection_id/publish HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/publish")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/publish"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/publish")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/publish")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/publish');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/publish';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/publish',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/publish")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/publish',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/publish'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/publish');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/publish';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/publish"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/publish" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/publish",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/publish');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/publish');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/publish' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/publish' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/collections/:collection_id/publish")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/publish"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/publish"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/publish")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/collections/:collection_id/publish') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/publish";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/publish

http POST {{baseUrl}}/account/collections/:collection_id/publish

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/publish

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/publish")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

POST Private Collection Reserve DOI

{{baseUrl}}/account/collections/:collection_id/reserve_doi

QUERY PARAMS

collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/reserve_doi");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/reserve_doi")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/reserve_doi"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/reserve_doi"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/reserve_doi");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/reserve_doi"

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

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

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

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

}

POST /baseUrl/account/collections/:collection_id/reserve_doi HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/reserve_doi")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/reserve_doi"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/reserve_doi")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/reserve_doi")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/reserve_doi');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_doi'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/reserve_doi';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_doi',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/reserve_doi")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/reserve_doi',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_doi'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/reserve_doi');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_doi'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/reserve_doi';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/reserve_doi"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/reserve_doi" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/reserve_doi",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/reserve_doi');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/reserve_doi');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/reserve_doi');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/reserve_doi' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/reserve_doi' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/collections/:collection_id/reserve_doi")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/reserve_doi"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/reserve_doi"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/reserve_doi")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/collections/:collection_id/reserve_doi') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/reserve_doi";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/reserve_doi

http POST {{baseUrl}}/account/collections/:collection_id/reserve_doi

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/reserve_doi

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/reserve_doi")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "doi": "10.5072/FK2.FIGSHARE.20345"
}

POST Private Collection Reserve Handle

{{baseUrl}}/account/collections/:collection_id/reserve_handle

QUERY PARAMS

collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/reserve_handle");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/reserve_handle")

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/reserve_handle"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/reserve_handle"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/reserve_handle");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/reserve_handle"

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

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

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

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

}

POST /baseUrl/account/collections/:collection_id/reserve_handle HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/reserve_handle")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/reserve_handle"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/reserve_handle")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/reserve_handle")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/reserve_handle');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_handle'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/reserve_handle';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_handle',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/reserve_handle")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/reserve_handle',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_handle'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/reserve_handle');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/reserve_handle'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/reserve_handle';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/reserve_handle"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/reserve_handle" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/reserve_handle",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/reserve_handle');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/reserve_handle');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections/:collection_id/reserve_handle');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/reserve_handle' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/reserve_handle' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/collections/:collection_id/reserve_handle")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/reserve_handle"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/reserve_handle"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/reserve_handle")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/collections/:collection_id/reserve_handle') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/reserve_handle";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/reserve_handle

http POST {{baseUrl}}/account/collections/:collection_id/reserve_handle

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/reserve_handle

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/reserve_handle")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "handle": "11172/FK2.FIGSHARE.20345"
}

POST Private Collection Resource

{{baseUrl}}/account/collections/:collection_id/resource

QUERY PARAMS

collection_id

BODY json

{
  "doi": "",
  "id": "",
  "link": "",
  "status": "",
  "title": "",
  "version": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/resource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/:collection_id/resource" {:content-type :json
                                                                                        :form-params {:id "aaaa23512"
                                                                                                      :link "https://docs.figshare.com"
                                                                                                      :status "frozen"
                                                                                                      :title "Test title"
                                                                                                      :version 1}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/resource"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/resource"),
    Content = new StringContent("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/resource");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/resource"

	payload := strings.NewReader("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")

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

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

}

POST /baseUrl/account/collections/:collection_id/resource HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/:collection_id/resource")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/resource"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/resource")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/:collection_id/resource")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
  .asString();

const data = JSON.stringify({
  id: 'aaaa23512',
  link: 'https://docs.figshare.com',
  status: 'frozen',
  title: 'Test title',
  version: 1
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/:collection_id/resource');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/resource',
  headers: {'content-type': 'application/json'},
  data: {
    id: 'aaaa23512',
    link: 'https://docs.figshare.com',
    status: 'frozen',
    title: 'Test title',
    version: 1
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/resource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"aaaa23512","link":"https://docs.figshare.com","status":"frozen","title":"Test title","version":1}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/resource',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "aaaa23512",\n  "link": "https://docs.figshare.com",\n  "status": "frozen",\n  "title": "Test title",\n  "version": 1\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/resource")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/resource',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  id: 'aaaa23512',
  link: 'https://docs.figshare.com',
  status: 'frozen',
  title: 'Test title',
  version: 1
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/resource',
  headers: {'content-type': 'application/json'},
  body: {
    id: 'aaaa23512',
    link: 'https://docs.figshare.com',
    status: 'frozen',
    title: 'Test title',
    version: 1
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/:collection_id/resource');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: 'aaaa23512',
  link: 'https://docs.figshare.com',
  status: 'frozen',
  title: 'Test title',
  version: 1
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/:collection_id/resource',
  headers: {'content-type': 'application/json'},
  data: {
    id: 'aaaa23512',
    link: 'https://docs.figshare.com',
    status: 'frozen',
    title: 'Test title',
    version: 1
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/resource';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"aaaa23512","link":"https://docs.figshare.com","status":"frozen","title":"Test title","version":1}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @"aaaa23512",
                              @"link": @"https://docs.figshare.com",
                              @"status": @"frozen",
                              @"title": @"Test title",
                              @"version": @1 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/resource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/resource" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/resource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => 'aaaa23512',
    'link' => 'https://docs.figshare.com',
    'status' => 'frozen',
    'title' => 'Test title',
    'version' => 1
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/:collection_id/resource', [
  'body' => '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/resource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => 'aaaa23512',
  'link' => 'https://docs.figshare.com',
  'status' => 'frozen',
  'title' => 'Test title',
  'version' => 1
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => 'aaaa23512',
  'link' => 'https://docs.figshare.com',
  'status' => 'frozen',
  'title' => 'Test title',
  'version' => 1
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/resource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/resource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/resource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections/:collection_id/resource", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/resource"

payload = {
    "id": "aaaa23512",
    "link": "https://docs.figshare.com",
    "status": "frozen",
    "title": "Test title",
    "version": 1
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/resource"

payload <- "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/resource")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections/:collection_id/resource') do |req|
  req.body = "{\n  \"id\": \"aaaa23512\",\n  \"link\": \"https://docs.figshare.com\",\n  \"status\": \"frozen\",\n  \"title\": \"Test title\",\n  \"version\": 1\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/resource";

    let payload = json!({
        "id": "aaaa23512",
        "link": "https://docs.figshare.com",
        "status": "frozen",
        "title": "Test title",
        "version": 1
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/:collection_id/resource \
  --header 'content-type: application/json' \
  --data '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}'

echo '{
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
}' |  \
  http POST {{baseUrl}}/account/collections/:collection_id/resource \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "aaaa23512",\n  "link": "https://docs.figshare.com",\n  "status": "frozen",\n  "title": "Test title",\n  "version": 1\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/resource

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "aaaa23512",
  "link": "https://docs.figshare.com",
  "status": "frozen",
  "title": "Test title",
  "version": 1
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/resource")! 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()

GET Private Collections List

{{baseUrl}}/account/collections

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/collections")

require "http/client"

url = "{{baseUrl}}/account/collections"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/collections"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections"

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

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

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

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

}

GET /baseUrl/account/collections HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/collections")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/collections")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/collections');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/collections'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/collections")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/collections'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/collections');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/collections'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/collections');

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/collections');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/collections")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/collections') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/collections

http GET {{baseUrl}}/account/collections

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/collections

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "doi": "10.6084/m9.figshare.123",
    "handle": "111184/figshare.1234",
    "id": 123,
    "published_date": "2015-08-12T00:39:55",
    "title": "Sample collection",
    "url": "https://api.figshare.com/v2/collections/123"
  }
]

POST Private Collections Search

{{baseUrl}}/account/collections/search

BODY json

{
  "resource_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resource_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/collections/search" {:content-type :json
                                                                       :form-params {:resource_id ""}})

require "http/client"

url = "{{baseUrl}}/account/collections/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resource_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/collections/search"),
    Content = new StringContent("{\n  \"resource_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resource_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/search"

	payload := strings.NewReader("{\n  \"resource_id\": \"\"\n}")

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

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

}

POST /baseUrl/account/collections/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "resource_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/collections/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resource_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resource_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resource_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/collections/search")
  .header("content-type", "application/json")
  .body("{\n  \"resource_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resource_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/collections/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/search',
  headers: {'content-type': 'application/json'},
  data: {resource_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resource_id":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resource_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resource_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/search',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resource_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/search',
  headers: {'content-type': 'application/json'},
  body: {resource_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/collections/search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resource_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/collections/search',
  headers: {'content-type': 'application/json'},
  data: {resource_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resource_id":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resource_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resource_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resource_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/collections/search', [
  'body' => '{
  "resource_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resource_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resource_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/search');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resource_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resource_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resource_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/collections/search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/search"

payload = { "resource_id": "" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/search"

payload <- "{\n  \"resource_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/search")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"resource_id\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/collections/search') do |req|
  req.body = "{\n  \"resource_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/search";

    let payload = json!({"resource_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/collections/search \
  --header 'content-type: application/json' \
  --data '{
  "resource_id": ""
}'

echo '{
  "resource_id": ""
}' |  \
  http POST {{baseUrl}}/account/collections/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resource_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["resource_id": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/search")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "doi": "10.6084/m9.figshare.123",
    "handle": "111184/figshare.1234",
    "id": 123,
    "published_date": "2015-08-12T00:39:55",
    "title": "Sample collection",
    "url": "https://api.figshare.com/v2/collections/123"
  }
]

GET Public Collection Articles

{{baseUrl}}/collections/:collection_id/articles

QUERY PARAMS

collection_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection_id/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/collections/:collection_id/articles")

require "http/client"

url = "{{baseUrl}}/collections/:collection_id/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/collections/:collection_id/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/collections/:collection_id/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/collections/:collection_id/articles"

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

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

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

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

}

GET /baseUrl/collections/:collection_id/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:collection_id/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/collections/:collection_id/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/collections/:collection_id/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/collections/:collection_id/articles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/collections/:collection_id/articles';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/collections/:collection_id/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/collections/:collection_id/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/collections/:collection_id/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/articles'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/collections/:collection_id/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/collections/:collection_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/collections/:collection_id/articles';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/:collection_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/collections/:collection_id/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/collections/:collection_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/collections/:collection_id/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/collections/:collection_id/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/collections/:collection_id/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection_id/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection_id/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/collections/:collection_id/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/collections/:collection_id/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/collections/:collection_id/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/collections/:collection_id/articles")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/collections/:collection_id/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/collections/:collection_id/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/collections/:collection_id/articles

http GET {{baseUrl}}/collections/:collection_id/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/collections/:collection_id/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection_id/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

POST Public Collections Search

{{baseUrl}}/collections/search

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/search");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/collections/search")

require "http/client"

url = "{{baseUrl}}/collections/search"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/collections/search"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/collections/search");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/collections/search"

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

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

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

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

}

POST /baseUrl/collections/search HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/collections/search")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/collections/search"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/collections/search")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/collections/search")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/collections/search');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/collections/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/collections/search';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/collections/search',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/collections/search")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/collections/search',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/collections/search'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/collections/search');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/collections/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/collections/search';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/collections/search" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/collections/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/collections/search');

echo $response->getBody();

setUrl('{{baseUrl}}/collections/search');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/collections/search');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/search' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/search' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/collections/search")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/collections/search"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/collections/search"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/collections/search")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/collections/search') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/collections/search";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/collections/search

http POST {{baseUrl}}/collections/search

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/collections/search

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

GET Public Collections

{{baseUrl}}/collections

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/collections")

require "http/client"

url = "{{baseUrl}}/collections"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/collections"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/collections");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/collections"

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

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

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

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

}

GET /baseUrl/collections HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/collections"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/collections")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/collections")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/collections');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/collections'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/collections';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/collections',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/collections")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/collections',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/collections'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/collections');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/collections'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/collections';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/collections" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/collections",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/collections');

echo $response->getBody();

setUrl('{{baseUrl}}/collections');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/collections');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/collections")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/collections"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/collections"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/collections")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/collections') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/collections";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/collections

http GET {{baseUrl}}/collections

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/collections

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

PUT Replace collection articles

{{baseUrl}}/account/collections/:collection_id/articles

BODY json

{
  "articles": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/articles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/collections/:collection_id/articles" {:content-type :json
                                                                                       :form-params {:articles [2000003 2000004]}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/articles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/articles"),
    Content = new StringContent("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/articles");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/articles"

	payload := strings.NewReader("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")

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

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

}

PUT /baseUrl/account/collections/:collection_id/articles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "articles": [
    2000003,
    2000004
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/collections/:collection_id/articles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/articles"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/collections/:collection_id/articles")
  .header("content-type", "application/json")
  .body("{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
  .asString();

const data = JSON.stringify({
  articles: [
    2000003,
    2000004
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/collections/:collection_id/articles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  headers: {'content-type': 'application/json'},
  data: {articles: [2000003, 2000004]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/articles';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[2000003,2000004]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "articles": [\n    2000003,\n    2000004\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/articles")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/articles',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({articles: [2000003, 2000004]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  headers: {'content-type': 'application/json'},
  body: {articles: [2000003, 2000004]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/collections/:collection_id/articles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  articles: [
    2000003,
    2000004
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/articles',
  headers: {'content-type': 'application/json'},
  data: {articles: [2000003, 2000004]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/articles';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[2000003,2000004]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"articles": @[ @2000003, @2000004 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/articles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'articles' => [
        2000003,
        2000004
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/collections/:collection_id/articles', [
  'body' => '{
  "articles": [
    2000003,
    2000004
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/articles');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'articles' => [
    2000003,
    2000004
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'articles' => [
    2000003,
    2000004
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/articles');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/articles' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [
    2000003,
    2000004
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/articles' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [
    2000003,
    2000004
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/collections/:collection_id/articles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/articles"

payload = { "articles": [2000003, 2000004] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/articles"

payload <- "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/articles")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/collections/:collection_id/articles') do |req|
  req.body = "{\n  \"articles\": [\n    2000003,\n    2000004\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/articles";

    let payload = json!({"articles": (2000003, 2000004)});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/collections/:collection_id/articles \
  --header 'content-type: application/json' \
  --data '{
  "articles": [
    2000003,
    2000004
  ]
}'

echo '{
  "articles": [
    2000003,
    2000004
  ]
}' |  \
  http PUT {{baseUrl}}/account/collections/:collection_id/articles \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "articles": [\n    2000003,\n    2000004\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/articles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["articles": [2000003, 2000004]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Replace collection authors

{{baseUrl}}/account/collections/:collection_id/authors

BODY json

{
  "authors": [
    {}
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/authors");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/collections/:collection_id/authors" {:content-type :json
                                                                                      :form-params {:authors [{:id 12121} {:id 34345} {:name "John Doe"}]}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/authors"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/authors"),
    Content = new StringContent("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/authors");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/authors"

	payload := strings.NewReader("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")

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

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

}

PUT /baseUrl/account/collections/:collection_id/authors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 121

{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/collections/:collection_id/authors")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/authors"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/collections/:collection_id/authors")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/collections/:collection_id/authors');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/authors';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/authors")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/authors',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  headers: {'content-type': 'application/json'},
  body: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/collections/:collection_id/authors');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {
      id: 12121
    },
    {
      id: 34345
    },
    {
      name: 'John Doe'
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/authors',
  headers: {'content-type': 'application/json'},
  data: {authors: [{id: 12121}, {id: 34345}, {name: 'John Doe'}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/authors';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{"id":12121},{"id":34345},{"name":"John Doe"}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{ @"id": @12121 }, @{ @"id": @34345 }, @{ @"name": @"John Doe" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/authors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/authors" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/authors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                'id' => 12121
        ],
        [
                'id' => 34345
        ],
        [
                'name' => 'John Doe'
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/collections/:collection_id/authors', [
  'body' => '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/authors');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        'id' => 12121
    ],
    [
        'id' => 34345
    ],
    [
        'name' => 'John Doe'
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/authors');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/authors' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/authors' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/collections/:collection_id/authors", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/authors"

payload = { "authors": [{ "id": 12121 }, { "id": 34345 }, { "name": "John Doe" }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/authors"

payload <- "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/authors")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/collections/:collection_id/authors') do |req|
  req.body = "{\n  \"authors\": [\n    {\n      \"id\": 12121\n    },\n    {\n      \"id\": 34345\n    },\n    {\n      \"name\": \"John Doe\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/authors";

    let payload = json!({"authors": (json!({"id": 12121}), json!({"id": 34345}), json!({"name": "John Doe"}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/collections/:collection_id/authors \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}'

echo '{
  "authors": [
    {
      "id": 12121
    },
    {
      "id": 34345
    },
    {
      "name": "John Doe"
    }
  ]
}' |  \
  http PUT {{baseUrl}}/account/collections/:collection_id/authors \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {\n      "id": 12121\n    },\n    {\n      "id": 34345\n    },\n    {\n      "name": "John Doe"\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/authors

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["authors": [["id": 12121], ["id": 34345], ["name": "John Doe"]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/authors")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Replace collection categories

{{baseUrl}}/account/collections/:collection_id/categories

BODY json

{
  "categories": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/collections/:collection_id/categories" {:content-type :json
                                                                                         :form-params {:categories [1 10 11]}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/categories"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/categories"),
    Content = new StringContent("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/categories");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/categories"

	payload := strings.NewReader("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")

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

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

}

PUT /baseUrl/account/collections/:collection_id/categories HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "categories": [
    1,
    10,
    11
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/collections/:collection_id/categories")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/categories"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/collections/:collection_id/categories")
  .header("content-type", "application/json")
  .body("{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
  .asString();

const data = JSON.stringify({
  categories: [
    1,
    10,
    11
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/collections/:collection_id/categories');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/categories';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/categories")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/categories',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({categories: [1, 10, 11]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  headers: {'content-type': 'application/json'},
  body: {categories: [1, 10, 11]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/collections/:collection_id/categories');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  categories: [
    1,
    10,
    11
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/categories',
  headers: {'content-type': 'application/json'},
  data: {categories: [1, 10, 11]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/categories';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"categories":[1,10,11]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"categories": @[ @1, @10, @11 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/categories" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'categories' => [
        1,
        10,
        11
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/collections/:collection_id/categories', [
  'body' => '{
  "categories": [
    1,
    10,
    11
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/categories');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'categories' => [
    1,
    10,
    11
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/categories');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/categories' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/categories' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "categories": [
    1,
    10,
    11
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/collections/:collection_id/categories", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/categories"

payload = { "categories": [1, 10, 11] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/categories"

payload <- "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/categories")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/collections/:collection_id/categories') do |req|
  req.body = "{\n  \"categories\": [\n    1,\n    10,\n    11\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/categories";

    let payload = json!({"categories": (1, 10, 11)});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/collections/:collection_id/categories \
  --header 'content-type: application/json' \
  --data '{
  "categories": [
    1,
    10,
    11
  ]
}'

echo '{
  "categories": [
    1,
    10,
    11
  ]
}' |  \
  http PUT {{baseUrl}}/account/collections/:collection_id/categories \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "categories": [\n    1,\n    10,\n    11\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/categories

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["categories": [1, 10, 11]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update collection private link

{{baseUrl}}/account/collections/:collection_id/private_links/:link_id

BODY json

{
  "expires_date": "",
  "read_only": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id" {:content-type :json
                                                                                                     :form-params {:expires_date "2018-02-22 22:22:22"
                                                                                                                   :read_only true}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"),
    Content = new StringContent("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

	payload := strings.NewReader("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")

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

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

}

PUT /baseUrl/account/collections/:collection_id/private_links/:link_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .header("content-type", "application/json")
  .body("{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
  .asString();

const data = JSON.stringify({
  expires_date: '2018-02-22 22:22:22',
  read_only: true
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '2018-02-22 22:22:22', read_only: true}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"2018-02-22 22:22:22","read_only":true}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expires_date": "2018-02-22 22:22:22",\n  "read_only": true\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id/private_links/:link_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({expires_date: '2018-02-22 22:22:22', read_only: true}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id',
  headers: {'content-type': 'application/json'},
  body: {expires_date: '2018-02-22 22:22:22', read_only: true},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  expires_date: '2018-02-22 22:22:22',
  read_only: true
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id',
  headers: {'content-type': 'application/json'},
  data: {expires_date: '2018-02-22 22:22:22', read_only: true}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"expires_date":"2018-02-22 22:22:22","read_only":true}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expires_date": @"2018-02-22 22:22:22",
                              @"read_only": @YES };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'expires_date' => '2018-02-22 22:22:22',
    'read_only' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id', [
  'body' => '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expires_date' => '2018-02-22 22:22:22',
  'read_only' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'expires_date' => '2018-02-22 22:22:22',
  'read_only' => null
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id/private_links/:link_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id/private_links/:link_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/collections/:collection_id/private_links/:link_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

payload = {
    "expires_date": "2018-02-22 22:22:22",
    "read_only": True
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id"

payload <- "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/collections/:collection_id/private_links/:link_id') do |req|
  req.body = "{\n  \"expires_date\": \"2018-02-22 22:22:22\",\n  \"read_only\": true\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id";

    let payload = json!({
        "expires_date": "2018-02-22 22:22:22",
        "read_only": true
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/collections/:collection_id/private_links/:link_id \
  --header 'content-type: application/json' \
  --data '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}'

echo '{
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
}' |  \
  http PUT {{baseUrl}}/account/collections/:collection_id/private_links/:link_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "expires_date": "2018-02-22 22:22:22",\n  "read_only": true\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id/private_links/:link_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "expires_date": "2018-02-22 22:22:22",
  "read_only": true
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id/private_links/:link_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update collection

{{baseUrl}}/account/collections/:collection_id

BODY json

{
  "articles": [],
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "handle": "",
  "keywords": [],
  "references": [],
  "resource_doi": "",
  "resource_id": "",
  "resource_link": "",
  "resource_title": "",
  "resource_version": 0,
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/collections/:collection_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/collections/:collection_id" {:content-type :json
                                                                              :form-params {:articles [2000001 2000005]
                                                                                            :authors [{:name "John Doe"} {:id 20005}]
                                                                                            :categories [1 10 11]
                                                                                            :categories_by_source_id ["300204" "400207"]
                                                                                            :custom_fields {:defined_key "value for it"}
                                                                                            :description "Test description of collection"
                                                                                            :keywords ["tag1" "tag2"]
                                                                                            :references ["http://figshare.com" "http://api.figshare.com"]
                                                                                            :tags ["tag1" "tag2"]
                                                                                            :timeline {:firstOnline "2015-12-31"
                                                                                                       :publisherAcceptance "2015-12-31"
                                                                                                       :publisherPublication "2015-12-31"}
                                                                                            :title "Test collection title"}})

require "http/client"

url = "{{baseUrl}}/account/collections/:collection_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/collections/:collection_id"),
    Content = new StringContent("{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/collections/:collection_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/collections/:collection_id"

	payload := strings.NewReader("{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}")

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

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

}

PUT /baseUrl/account/collections/:collection_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 691

{
  "articles": [
    2000001,
    2000005
  ],
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 20005
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "Test description of collection",
  "keywords": [
    "tag1",
    "tag2"
  ],
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test collection title"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/collections/:collection_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/collections/:collection_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/collections/:collection_id")
  .header("content-type", "application/json")
  .body("{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}")
  .asString();

const data = JSON.stringify({
  articles: [
    2000001,
    2000005
  ],
  authors: [
    {
      name: 'John Doe'
    },
    {
      id: 20005
    }
  ],
  categories: [
    1,
    10,
    11
  ],
  categories_by_source_id: [
    '300204',
    '400207'
  ],
  custom_fields: {
    defined_key: 'value for it'
  },
  description: 'Test description of collection',
  keywords: [
    'tag1',
    'tag2'
  ],
  references: [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  tags: [
    'tag1',
    'tag2'
  ],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test collection title'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/collections/:collection_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id',
  headers: {'content-type': 'application/json'},
  data: {
    articles: [2000001, 2000005],
    authors: [{name: 'John Doe'}, {id: 20005}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    description: 'Test description of collection',
    keywords: ['tag1', 'tag2'],
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test collection title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/collections/:collection_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[2000001,2000005],"authors":[{"name":"John Doe"},{"id":20005}],"categories":[1,10,11],"categories_by_source_id":["300204","400207"],"custom_fields":{"defined_key":"value for it"},"description":"Test description of collection","keywords":["tag1","tag2"],"references":["http://figshare.com","http://api.figshare.com"],"tags":["tag1","tag2"],"timeline":{"firstOnline":"2015-12-31","publisherAcceptance":"2015-12-31","publisherPublication":"2015-12-31"},"title":"Test collection title"}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/collections/:collection_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "articles": [\n    2000001,\n    2000005\n  ],\n  "authors": [\n    {\n      "name": "John Doe"\n    },\n    {\n      "id": 20005\n    }\n  ],\n  "categories": [\n    1,\n    10,\n    11\n  ],\n  "categories_by_source_id": [\n    "300204",\n    "400207"\n  ],\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "description": "Test description of collection",\n  "keywords": [\n    "tag1",\n    "tag2"\n  ],\n  "references": [\n    "http://figshare.com",\n    "http://api.figshare.com"\n  ],\n  "tags": [\n    "tag1",\n    "tag2"\n  ],\n  "timeline": {\n    "firstOnline": "2015-12-31",\n    "publisherAcceptance": "2015-12-31",\n    "publisherPublication": "2015-12-31"\n  },\n  "title": "Test collection title"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/collections/:collection_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/collections/:collection_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  articles: [2000001, 2000005],
  authors: [{name: 'John Doe'}, {id: 20005}],
  categories: [1, 10, 11],
  categories_by_source_id: ['300204', '400207'],
  custom_fields: {defined_key: 'value for it'},
  description: 'Test description of collection',
  keywords: ['tag1', 'tag2'],
  references: ['http://figshare.com', 'http://api.figshare.com'],
  tags: ['tag1', 'tag2'],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test collection title'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id',
  headers: {'content-type': 'application/json'},
  body: {
    articles: [2000001, 2000005],
    authors: [{name: 'John Doe'}, {id: 20005}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    description: 'Test description of collection',
    keywords: ['tag1', 'tag2'],
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test collection title'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/collections/:collection_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  articles: [
    2000001,
    2000005
  ],
  authors: [
    {
      name: 'John Doe'
    },
    {
      id: 20005
    }
  ],
  categories: [
    1,
    10,
    11
  ],
  categories_by_source_id: [
    '300204',
    '400207'
  ],
  custom_fields: {
    defined_key: 'value for it'
  },
  description: 'Test description of collection',
  keywords: [
    'tag1',
    'tag2'
  ],
  references: [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  tags: [
    'tag1',
    'tag2'
  ],
  timeline: {
    firstOnline: '2015-12-31',
    publisherAcceptance: '2015-12-31',
    publisherPublication: '2015-12-31'
  },
  title: 'Test collection title'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/collections/:collection_id',
  headers: {'content-type': 'application/json'},
  data: {
    articles: [2000001, 2000005],
    authors: [{name: 'John Doe'}, {id: 20005}],
    categories: [1, 10, 11],
    categories_by_source_id: ['300204', '400207'],
    custom_fields: {defined_key: 'value for it'},
    description: 'Test description of collection',
    keywords: ['tag1', 'tag2'],
    references: ['http://figshare.com', 'http://api.figshare.com'],
    tags: ['tag1', 'tag2'],
    timeline: {
      firstOnline: '2015-12-31',
      publisherAcceptance: '2015-12-31',
      publisherPublication: '2015-12-31'
    },
    title: 'Test collection title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/collections/:collection_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"articles":[2000001,2000005],"authors":[{"name":"John Doe"},{"id":20005}],"categories":[1,10,11],"categories_by_source_id":["300204","400207"],"custom_fields":{"defined_key":"value for it"},"description":"Test description of collection","keywords":["tag1","tag2"],"references":["http://figshare.com","http://api.figshare.com"],"tags":["tag1","tag2"],"timeline":{"firstOnline":"2015-12-31","publisherAcceptance":"2015-12-31","publisherPublication":"2015-12-31"},"title":"Test collection title"}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"articles": @[ @2000001, @2000005 ],
                              @"authors": @[ @{ @"name": @"John Doe" }, @{ @"id": @20005 } ],
                              @"categories": @[ @1, @10, @11 ],
                              @"categories_by_source_id": @[ @"300204", @"400207" ],
                              @"custom_fields": @{ @"defined_key": @"value for it" },
                              @"description": @"Test description of collection",
                              @"keywords": @[ @"tag1", @"tag2" ],
                              @"references": @[ @"http://figshare.com", @"http://api.figshare.com" ],
                              @"tags": @[ @"tag1", @"tag2" ],
                              @"timeline": @{ @"firstOnline": @"2015-12-31", @"publisherAcceptance": @"2015-12-31", @"publisherPublication": @"2015-12-31" },
                              @"title": @"Test collection title" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/collections/:collection_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/collections/:collection_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/collections/:collection_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'articles' => [
        2000001,
        2000005
    ],
    'authors' => [
        [
                'name' => 'John Doe'
        ],
        [
                'id' => 20005
        ]
    ],
    'categories' => [
        1,
        10,
        11
    ],
    'categories_by_source_id' => [
        '300204',
        '400207'
    ],
    'custom_fields' => [
        'defined_key' => 'value for it'
    ],
    'description' => 'Test description of collection',
    'keywords' => [
        'tag1',
        'tag2'
    ],
    'references' => [
        'http://figshare.com',
        'http://api.figshare.com'
    ],
    'tags' => [
        'tag1',
        'tag2'
    ],
    'timeline' => [
        'firstOnline' => '2015-12-31',
        'publisherAcceptance' => '2015-12-31',
        'publisherPublication' => '2015-12-31'
    ],
    'title' => 'Test collection title'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/collections/:collection_id', [
  'body' => '{
  "articles": [
    2000001,
    2000005
  ],
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 20005
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "Test description of collection",
  "keywords": [
    "tag1",
    "tag2"
  ],
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test collection title"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/collections/:collection_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'articles' => [
    2000001,
    2000005
  ],
  'authors' => [
    [
        'name' => 'John Doe'
    ],
    [
        'id' => 20005
    ]
  ],
  'categories' => [
    1,
    10,
    11
  ],
  'categories_by_source_id' => [
    '300204',
    '400207'
  ],
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'description' => 'Test description of collection',
  'keywords' => [
    'tag1',
    'tag2'
  ],
  'references' => [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  'tags' => [
    'tag1',
    'tag2'
  ],
  'timeline' => [
    'firstOnline' => '2015-12-31',
    'publisherAcceptance' => '2015-12-31',
    'publisherPublication' => '2015-12-31'
  ],
  'title' => 'Test collection title'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'articles' => [
    2000001,
    2000005
  ],
  'authors' => [
    [
        'name' => 'John Doe'
    ],
    [
        'id' => 20005
    ]
  ],
  'categories' => [
    1,
    10,
    11
  ],
  'categories_by_source_id' => [
    '300204',
    '400207'
  ],
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'description' => 'Test description of collection',
  'keywords' => [
    'tag1',
    'tag2'
  ],
  'references' => [
    'http://figshare.com',
    'http://api.figshare.com'
  ],
  'tags' => [
    'tag1',
    'tag2'
  ],
  'timeline' => [
    'firstOnline' => '2015-12-31',
    'publisherAcceptance' => '2015-12-31',
    'publisherPublication' => '2015-12-31'
  ],
  'title' => 'Test collection title'
]));
$request->setRequestUrl('{{baseUrl}}/account/collections/:collection_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/collections/:collection_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [
    2000001,
    2000005
  ],
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 20005
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "Test description of collection",
  "keywords": [
    "tag1",
    "tag2"
  ],
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test collection title"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/collections/:collection_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "articles": [
    2000001,
    2000005
  ],
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 20005
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "Test description of collection",
  "keywords": [
    "tag1",
    "tag2"
  ],
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test collection title"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/collections/:collection_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/collections/:collection_id"

payload = {
    "articles": [2000001, 2000005],
    "authors": [{ "name": "John Doe" }, { "id": 20005 }],
    "categories": [1, 10, 11],
    "categories_by_source_id": ["300204", "400207"],
    "custom_fields": { "defined_key": "value for it" },
    "description": "Test description of collection",
    "keywords": ["tag1", "tag2"],
    "references": ["http://figshare.com", "http://api.figshare.com"],
    "tags": ["tag1", "tag2"],
    "timeline": {
        "firstOnline": "2015-12-31",
        "publisherAcceptance": "2015-12-31",
        "publisherPublication": "2015-12-31"
    },
    "title": "Test collection title"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/collections/:collection_id"

payload <- "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/collections/:collection_id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/collections/:collection_id') do |req|
  req.body = "{\n  \"articles\": [\n    2000001,\n    2000005\n  ],\n  \"authors\": [\n    {\n      \"name\": \"John Doe\"\n    },\n    {\n      \"id\": 20005\n    }\n  ],\n  \"categories\": [\n    1,\n    10,\n    11\n  ],\n  \"categories_by_source_id\": [\n    \"300204\",\n    \"400207\"\n  ],\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"Test description of collection\",\n  \"keywords\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"references\": [\n    \"http://figshare.com\",\n    \"http://api.figshare.com\"\n  ],\n  \"tags\": [\n    \"tag1\",\n    \"tag2\"\n  ],\n  \"timeline\": {\n    \"firstOnline\": \"2015-12-31\",\n    \"publisherAcceptance\": \"2015-12-31\",\n    \"publisherPublication\": \"2015-12-31\"\n  },\n  \"title\": \"Test collection title\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/collections/:collection_id";

    let payload = json!({
        "articles": (2000001, 2000005),
        "authors": (json!({"name": "John Doe"}), json!({"id": 20005})),
        "categories": (1, 10, 11),
        "categories_by_source_id": ("300204", "400207"),
        "custom_fields": json!({"defined_key": "value for it"}),
        "description": "Test description of collection",
        "keywords": ("tag1", "tag2"),
        "references": ("http://figshare.com", "http://api.figshare.com"),
        "tags": ("tag1", "tag2"),
        "timeline": json!({
            "firstOnline": "2015-12-31",
            "publisherAcceptance": "2015-12-31",
            "publisherPublication": "2015-12-31"
        }),
        "title": "Test collection title"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/collections/:collection_id \
  --header 'content-type: application/json' \
  --data '{
  "articles": [
    2000001,
    2000005
  ],
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 20005
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "Test description of collection",
  "keywords": [
    "tag1",
    "tag2"
  ],
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test collection title"
}'

echo '{
  "articles": [
    2000001,
    2000005
  ],
  "authors": [
    {
      "name": "John Doe"
    },
    {
      "id": 20005
    }
  ],
  "categories": [
    1,
    10,
    11
  ],
  "categories_by_source_id": [
    "300204",
    "400207"
  ],
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "Test description of collection",
  "keywords": [
    "tag1",
    "tag2"
  ],
  "references": [
    "http://figshare.com",
    "http://api.figshare.com"
  ],
  "tags": [
    "tag1",
    "tag2"
  ],
  "timeline": {
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  },
  "title": "Test collection title"
}' |  \
  http PUT {{baseUrl}}/account/collections/:collection_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "articles": [\n    2000001,\n    2000005\n  ],\n  "authors": [\n    {\n      "name": "John Doe"\n    },\n    {\n      "id": 20005\n    }\n  ],\n  "categories": [\n    1,\n    10,\n    11\n  ],\n  "categories_by_source_id": [\n    "300204",\n    "400207"\n  ],\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "description": "Test description of collection",\n  "keywords": [\n    "tag1",\n    "tag2"\n  ],\n  "references": [\n    "http://figshare.com",\n    "http://api.figshare.com"\n  ],\n  "tags": [\n    "tag1",\n    "tag2"\n  ],\n  "timeline": {\n    "firstOnline": "2015-12-31",\n    "publisherAcceptance": "2015-12-31",\n    "publisherPublication": "2015-12-31"\n  },\n  "title": "Test collection title"\n}' \
  --output-document \
  - {{baseUrl}}/account/collections/:collection_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "articles": [2000001, 2000005],
  "authors": [["name": "John Doe"], ["id": 20005]],
  "categories": [1, 10, 11],
  "categories_by_source_id": ["300204", "400207"],
  "custom_fields": ["defined_key": "value for it"],
  "description": "Test description of collection",
  "keywords": ["tag1", "tag2"],
  "references": ["http://figshare.com", "http://api.figshare.com"],
  "tags": ["tag1", "tag2"],
  "timeline": [
    "firstOnline": "2015-12-31",
    "publisherAcceptance": "2015-12-31",
    "publisherPublication": "2015-12-31"
  ],
  "title": "Test collection title"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/collections/:collection_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

POST Add Institution Account Group Roles

{{baseUrl}}/account/institution/roles/:account_id

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/roles/:account_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/institution/roles/:account_id" {:content-type :json
                                                                                  :form-params {:2 [2 7]
                                                                                                :3 [7 9]}})

require "http/client"

url = "{{baseUrl}}/account/institution/roles/:account_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/institution/roles/:account_id"),
    Content = new StringContent("{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/roles/:account_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/institution/roles/:account_id"

	payload := strings.NewReader("{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}")

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

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

}

POST /baseUrl/account/institution/roles/:account_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "2": [
    2,
    7
  ],
  "3": [
    7,
    9
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/institution/roles/:account_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/roles/:account_id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/roles/:account_id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/institution/roles/:account_id")
  .header("content-type", "application/json")
  .body("{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}")
  .asString();

const data = JSON.stringify({
  '2': [
    2,
    7
  ],
  '3': [
    7,
    9
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/institution/roles/:account_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/roles/:account_id',
  headers: {'content-type': 'application/json'},
  data: {'2': [2, 7], '3': [7, 9]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/roles/:account_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"2":[2,7],"3":[7,9]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/roles/:account_id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "2": [\n    2,\n    7\n  ],\n  "3": [\n    7,\n    9\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/roles/:account_id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/roles/:account_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({'2': [2, 7], '3': [7, 9]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/roles/:account_id',
  headers: {'content-type': 'application/json'},
  body: {'2': [2, 7], '3': [7, 9]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/institution/roles/:account_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  '2': [
    2,
    7
  ],
  '3': [
    7,
    9
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/roles/:account_id',
  headers: {'content-type': 'application/json'},
  data: {'2': [2, 7], '3': [7, 9]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/roles/:account_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"2":[2,7],"3":[7,9]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"2": @[ @2, @7 ],
                              @"3": @[ @7, @9 ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/roles/:account_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/roles/:account_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/roles/:account_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    '2' => [
        2,
        7
    ],
    '3' => [
        7,
        9
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/institution/roles/:account_id', [
  'body' => '{
  "2": [
    2,
    7
  ],
  "3": [
    7,
    9
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/roles/:account_id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  '2' => [
    2,
    7
  ],
  '3' => [
    7,
    9
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  '2' => [
    2,
    7
  ],
  '3' => [
    7,
    9
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account/institution/roles/:account_id');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/roles/:account_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "2": [
    2,
    7
  ],
  "3": [
    7,
    9
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/roles/:account_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "2": [
    2,
    7
  ],
  "3": [
    7,
    9
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/institution/roles/:account_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/roles/:account_id"

payload = {
    "2": [2, 7],
    "3": [7, 9]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/roles/:account_id"

payload <- "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/roles/:account_id")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/institution/roles/:account_id') do |req|
  req.body = "{\n  \"2\": [\n    2,\n    7\n  ],\n  \"3\": [\n    7,\n    9\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/roles/:account_id";

    let payload = json!({
        "2": (2, 7),
        "3": (7, 9)
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/institution/roles/:account_id \
  --header 'content-type: application/json' \
  --data '{
  "2": [
    2,
    7
  ],
  "3": [
    7,
    9
  ]
}'

echo '{
  "2": [
    2,
    7
  ],
  "3": [
    7,
    9
  ]
}' |  \
  http POST {{baseUrl}}/account/institution/roles/:account_id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "2": [\n    2,\n    7\n  ],\n  "3": [\n    7,\n    9\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account/institution/roles/:account_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "2": [2, 7],
  "3": [7, 9]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/roles/:account_id")! 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()

POST Create new Institution Account

{{baseUrl}}/account/institution/accounts

BODY json

{
  "email": "",
  "first_name": "",
  "group_id": 0,
  "institution_user_id": "",
  "is_active": false,
  "last_name": "",
  "quota": 0,
  "symplectic_user_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/accounts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/institution/accounts" {:content-type :json
                                                                         :form-params {:email "johndoe@example.com"
                                                                                       :first_name "John"
                                                                                       :institution_user_id "johndoe"
                                                                                       :last_name "Doe"
                                                                                       :quota 1000
                                                                                       :symplectic_user_id "johndoe"}})

require "http/client"

url = "{{baseUrl}}/account/institution/accounts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/institution/accounts"),
    Content = new StringContent("{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/accounts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/institution/accounts"

	payload := strings.NewReader("{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}")

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

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

}

POST /baseUrl/account/institution/accounts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 170

{
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/institution/accounts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/accounts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/institution/accounts")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}")
  .asString();

const data = JSON.stringify({
  email: 'johndoe@example.com',
  first_name: 'John',
  institution_user_id: 'johndoe',
  last_name: 'Doe',
  quota: 1000,
  symplectic_user_id: 'johndoe'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/institution/accounts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/accounts',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'johndoe@example.com',
    first_name: 'John',
    institution_user_id: 'johndoe',
    last_name: 'Doe',
    quota: 1000,
    symplectic_user_id: 'johndoe'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/accounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"johndoe@example.com","first_name":"John","institution_user_id":"johndoe","last_name":"Doe","quota":1000,"symplectic_user_id":"johndoe"}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/accounts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "johndoe@example.com",\n  "first_name": "John",\n  "institution_user_id": "johndoe",\n  "last_name": "Doe",\n  "quota": 1000,\n  "symplectic_user_id": "johndoe"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/accounts',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  email: 'johndoe@example.com',
  first_name: 'John',
  institution_user_id: 'johndoe',
  last_name: 'Doe',
  quota: 1000,
  symplectic_user_id: 'johndoe'
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/accounts',
  headers: {'content-type': 'application/json'},
  body: {
    email: 'johndoe@example.com',
    first_name: 'John',
    institution_user_id: 'johndoe',
    last_name: 'Doe',
    quota: 1000,
    symplectic_user_id: 'johndoe'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/institution/accounts');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: 'johndoe@example.com',
  first_name: 'John',
  institution_user_id: 'johndoe',
  last_name: 'Doe',
  quota: 1000,
  symplectic_user_id: 'johndoe'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/accounts',
  headers: {'content-type': 'application/json'},
  data: {
    email: 'johndoe@example.com',
    first_name: 'John',
    institution_user_id: 'johndoe',
    last_name: 'Doe',
    quota: 1000,
    symplectic_user_id: 'johndoe'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/accounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"johndoe@example.com","first_name":"John","institution_user_id":"johndoe","last_name":"Doe","quota":1000,"symplectic_user_id":"johndoe"}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"johndoe@example.com",
                              @"first_name": @"John",
                              @"institution_user_id": @"johndoe",
                              @"last_name": @"Doe",
                              @"quota": @1000,
                              @"symplectic_user_id": @"johndoe" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/accounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/accounts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'email' => 'johndoe@example.com',
    'first_name' => 'John',
    'institution_user_id' => 'johndoe',
    'last_name' => 'Doe',
    'quota' => 1000,
    'symplectic_user_id' => 'johndoe'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/institution/accounts', [
  'body' => '{
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/accounts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => 'johndoe@example.com',
  'first_name' => 'John',
  'institution_user_id' => 'johndoe',
  'last_name' => 'Doe',
  'quota' => 1000,
  'symplectic_user_id' => 'johndoe'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'email' => 'johndoe@example.com',
  'first_name' => 'John',
  'institution_user_id' => 'johndoe',
  'last_name' => 'Doe',
  'quota' => 1000,
  'symplectic_user_id' => 'johndoe'
]));
$request->setRequestUrl('{{baseUrl}}/account/institution/accounts');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/accounts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/accounts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/institution/accounts", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/accounts"

payload = {
    "email": "johndoe@example.com",
    "first_name": "John",
    "institution_user_id": "johndoe",
    "last_name": "Doe",
    "quota": 1000,
    "symplectic_user_id": "johndoe"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/accounts"

payload <- "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/accounts")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/institution/accounts') do |req|
  req.body = "{\n  \"email\": \"johndoe@example.com\",\n  \"first_name\": \"John\",\n  \"institution_user_id\": \"johndoe\",\n  \"last_name\": \"Doe\",\n  \"quota\": 1000,\n  \"symplectic_user_id\": \"johndoe\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/accounts";

    let payload = json!({
        "email": "johndoe@example.com",
        "first_name": "John",
        "institution_user_id": "johndoe",
        "last_name": "Doe",
        "quota": 1000,
        "symplectic_user_id": "johndoe"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/institution/accounts \
  --header 'content-type: application/json' \
  --data '{
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
}'

echo '{
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
}' |  \
  http POST {{baseUrl}}/account/institution/accounts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "johndoe@example.com",\n  "first_name": "John",\n  "institution_user_id": "johndoe",\n  "last_name": "Doe",\n  "quota": 1000,\n  "symplectic_user_id": "johndoe"\n}' \
  --output-document \
  - {{baseUrl}}/account/institution/accounts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "email": "johndoe@example.com",
  "first_name": "John",
  "institution_user_id": "johndoe",
  "last_name": "Doe",
  "quota": 1000,
  "symplectic_user_id": "johndoe"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/accounts")! 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()

POST Custom fields values files upload

{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload

QUERY PARAMS

custom_field_id

BODY multipartForm

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload" {:multipart [{:name "external_file"
                                                                                                                         :content ""}]})

require "http/client"

url = "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "external_file",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

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

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

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

}

POST /baseUrl/account/institution/custom_fields/:custom_field_id/items/upload HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 122

-----011000010111000001101001
Content-Disposition: form-data; name="external_file"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('external_file', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('external_file', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload';
const form = new FormData();
form.append('external_file', '');

const options = {method: 'POST'};

options.body = form;

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

const form = new FormData();
form.append('external_file', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/custom_fields/:custom_field_id/items/upload',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write('-----011000010111000001101001\r\nContent-Disposition: form-data; name="external_file"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {external_file: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="external_file"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('external_file', '');

const url = '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload';
const options = {method: 'POST'};
options.body = formData;

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

#import 

NSDictionary *headers = @{ @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"external_file", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="external_file"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="external_file"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="external_file"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/account/institution/custom_fields/:custom_field_id/items/upload", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/account/institution/custom_fields/:custom_field_id/items/upload') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"external_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload";

    let form = reqwest::multipart::Form::new()
        .text("external_file", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload \
  --header 'content-type: multipart/form-data' \
  --form external_file=

echo '-----011000010111000001101001
Content-Disposition: form-data; name="external_file"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'

wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="external_file"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload

import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "external_file",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/custom_fields/:custom_field_id/items/upload")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "message": "OK"
}

DELETE Delete Institution Account Group Role

{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id

QUERY PARAMS

account_id

group_id

role_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")

require "http/client"

url = "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/account/institution/roles/:account_id/:group_id/:role_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/roles/:account_id/:group_id/:role_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/institution/roles/:account_id/:group_id/:role_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/institution/roles/:account_id/:group_id/:role_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id

http DELETE {{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/roles/:account_id/:group_id/:role_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

GET Institution Curation Review Comments

{{baseUrl}}/account/institution/review/:curation_id/comments

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/review/:curation_id/comments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/review/:curation_id/comments")

require "http/client"

url = "{{baseUrl}}/account/institution/review/:curation_id/comments"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/review/:curation_id/comments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/review/:curation_id/comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/review/:curation_id/comments"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/review/:curation_id/comments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/review/:curation_id/comments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/review/:curation_id/comments"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/review/:curation_id/comments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/review/:curation_id/comments")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/review/:curation_id/comments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/review/:curation_id/comments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/review/:curation_id/comments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/review/:curation_id/comments',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/review/:curation_id/comments');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/review/:curation_id/comments';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/review/:curation_id/comments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/review/:curation_id/comments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/review/:curation_id/comments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/review/:curation_id/comments');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/review/:curation_id/comments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/review/:curation_id/comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/review/:curation_id/comments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/review/:curation_id/comments' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/review/:curation_id/comments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/review/:curation_id/comments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/review/:curation_id/comments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/review/:curation_id/comments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/review/:curation_id/comments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/review/:curation_id/comments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/review/:curation_id/comments

http GET {{baseUrl}}/account/institution/review/:curation_id/comments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/review/:curation_id/comments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/review/:curation_id/comments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Institution Curation Review

{{baseUrl}}/account/institution/review/:curation_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/review/:curation_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/review/:curation_id")

require "http/client"

url = "{{baseUrl}}/account/institution/review/:curation_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/review/:curation_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/review/:curation_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/review/:curation_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/review/:curation_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/review/:curation_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/review/:curation_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/review/:curation_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/review/:curation_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/review/:curation_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/review/:curation_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/review/:curation_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/review/:curation_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/review/:curation_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/review/:curation_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/review/:curation_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/review/:curation_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/review/:curation_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/review/:curation_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/review/:curation_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/review/:curation_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/review/:curation_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/review/:curation_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/review/:curation_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/review/:curation_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/review/:curation_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/review/:curation_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/review/:curation_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/review/:curation_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/review/:curation_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/review/:curation_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/review/:curation_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/review/:curation_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/review/:curation_id

http GET {{baseUrl}}/account/institution/review/:curation_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/review/:curation_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/review/:curation_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "item": {
    "figshare_url": "http://figshare.com/articles/media/article_name/2000005",
    "resource_doi": "10.5072/FK2.developmentfigshare.2000005",
    "resource_title": "first article"
  }
}

GET Institution Curation Reviews

{{baseUrl}}/account/institution/reviews

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/reviews");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/reviews")

require "http/client"

url = "{{baseUrl}}/account/institution/reviews"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/reviews"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/reviews");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/reviews"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/reviews HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/reviews")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/reviews"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/reviews")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/reviews")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/reviews');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/reviews'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/reviews';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/reviews',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/reviews")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/reviews',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/reviews'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/reviews');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/reviews'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/reviews';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/reviews"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/reviews" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/reviews",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/reviews');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/reviews');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/reviews');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/reviews' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/reviews' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/reviews")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/reviews"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/reviews"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/reviews")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/reviews') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/reviews";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/reviews

http GET {{baseUrl}}/account/institution/reviews

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/reviews

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/reviews")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET List Institution Account Group Roles

{{baseUrl}}/account/institution/roles/:account_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/roles/:account_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/roles/:account_id")

require "http/client"

url = "{{baseUrl}}/account/institution/roles/:account_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/roles/:account_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/roles/:account_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/roles/:account_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/roles/:account_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/roles/:account_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/roles/:account_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/roles/:account_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/roles/:account_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/roles/:account_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/roles/:account_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/roles/:account_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/roles/:account_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/roles/:account_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/roles/:account_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/roles/:account_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/roles/:account_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/roles/:account_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/roles/:account_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/roles/:account_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/roles/:account_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/roles/:account_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/roles/:account_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/roles/:account_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/roles/:account_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/roles/:account_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/roles/:account_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/roles/:account_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/roles/:account_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/roles/:account_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/roles/:account_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/roles/:account_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/roles/:account_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/roles/:account_id

http GET {{baseUrl}}/account/institution/roles/:account_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/roles/:account_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/roles/:account_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "2": [
    {
      "category": "group",
      "id": 7,
      "name": "User"
    }
  ]
}

POST POST Institution Curation Review Comment

{{baseUrl}}/account/institution/review/:curation_id/comments

BODY json

{
  "text": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/review/:curation_id/comments");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"text\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/institution/review/:curation_id/comments" {:content-type :json
                                                                                             :form-params {:text ""}})

require "http/client"

url = "{{baseUrl}}/account/institution/review/:curation_id/comments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"text\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/institution/review/:curation_id/comments"),
    Content = new StringContent("{\n  \"text\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/review/:curation_id/comments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"text\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/review/:curation_id/comments"

	payload := strings.NewReader("{\n  \"text\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/institution/review/:curation_id/comments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "text": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/institution/review/:curation_id/comments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"text\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/review/:curation_id/comments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"text\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"text\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/review/:curation_id/comments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/institution/review/:curation_id/comments")
  .header("content-type", "application/json")
  .body("{\n  \"text\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  text: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/institution/review/:curation_id/comments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments',
  headers: {'content-type': 'application/json'},
  data: {text: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/review/:curation_id/comments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"text":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "text": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"text\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/review/:curation_id/comments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/review/:curation_id/comments',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({text: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments',
  headers: {'content-type': 'application/json'},
  body: {text: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/institution/review/:curation_id/comments');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  text: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/review/:curation_id/comments',
  headers: {'content-type': 'application/json'},
  data: {text: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/review/:curation_id/comments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"text":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"text": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/review/:curation_id/comments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/review/:curation_id/comments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"text\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/review/:curation_id/comments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'text' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/institution/review/:curation_id/comments', [
  'body' => '{
  "text": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/review/:curation_id/comments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'text' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'text' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/institution/review/:curation_id/comments');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/review/:curation_id/comments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "text": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/review/:curation_id/comments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "text": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"text\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/institution/review/:curation_id/comments", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/review/:curation_id/comments"

payload = { "text": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/review/:curation_id/comments"

payload <- "{\n  \"text\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/review/:curation_id/comments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"text\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/institution/review/:curation_id/comments') do |req|
  req.body = "{\n  \"text\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/review/:curation_id/comments";

    let payload = json!({"text": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/institution/review/:curation_id/comments \
  --header 'content-type: application/json' \
  --data '{
  "text": ""
}'

echo '{
  "text": ""
}' |  \
  http POST {{baseUrl}}/account/institution/review/:curation_id/comments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "text": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/institution/review/:curation_id/comments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["text": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/review/:curation_id/comments")! 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()

GET Private Account Categories

{{baseUrl}}/account/categories

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/categories")

require "http/client"

url = "{{baseUrl}}/account/categories"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/categories"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/categories")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/categories');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/categories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/categories'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/categories');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/account/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/categories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/categories' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/categories

http GET {{baseUrl}}/account/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": 11,
    "parent_id": 1,
    "path": "/450/1024/6532",
    "source_id": "300204",
    "taxonomy_id": 4,
    "title": "Anatomy"
  }
]

POST Private Account Institution Accounts Search

{{baseUrl}}/account/institution/accounts/search

BODY json

{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/accounts/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/institution/accounts/search" {:content-type :json
                                                                                :form-params {:email ""
                                                                                              :institution_user_id ""
                                                                                              :is_active 0
                                                                                              :limit 0
                                                                                              :offset 0
                                                                                              :page 0
                                                                                              :page_size 0
                                                                                              :search_for ""}})

require "http/client"

url = "{{baseUrl}}/account/institution/accounts/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/institution/accounts/search"),
    Content = new StringContent("{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/accounts/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/accounts/search"

	payload := strings.NewReader("{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/institution/accounts/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 144

{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/institution/accounts/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/accounts/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/institution/accounts/search")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  email: '',
  institution_user_id: '',
  is_active: 0,
  limit: 0,
  offset: 0,
  page: 0,
  page_size: 0,
  search_for: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/institution/accounts/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/accounts/search',
  headers: {'content-type': 'application/json'},
  data: {
    email: '',
    institution_user_id: '',
    is_active: 0,
    limit: 0,
    offset: 0,
    page: 0,
    page_size: 0,
    search_for: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/accounts/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"","institution_user_id":"","is_active":0,"limit":0,"offset":0,"page":0,"page_size":0,"search_for":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/accounts/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "",\n  "institution_user_id": "",\n  "is_active": 0,\n  "limit": 0,\n  "offset": 0,\n  "page": 0,\n  "page_size": 0,\n  "search_for": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/accounts/search',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  email: '',
  institution_user_id: '',
  is_active: 0,
  limit: 0,
  offset: 0,
  page: 0,
  page_size: 0,
  search_for: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/accounts/search',
  headers: {'content-type': 'application/json'},
  body: {
    email: '',
    institution_user_id: '',
    is_active: 0,
    limit: 0,
    offset: 0,
    page: 0,
    page_size: 0,
    search_for: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/institution/accounts/search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: '',
  institution_user_id: '',
  is_active: 0,
  limit: 0,
  offset: 0,
  page: 0,
  page_size: 0,
  search_for: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/institution/accounts/search',
  headers: {'content-type': 'application/json'},
  data: {
    email: '',
    institution_user_id: '',
    is_active: 0,
    limit: 0,
    offset: 0,
    page: 0,
    page_size: 0,
    search_for: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/accounts/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"","institution_user_id":"","is_active":0,"limit":0,"offset":0,"page":0,"page_size":0,"search_for":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"",
                              @"institution_user_id": @"",
                              @"is_active": @0,
                              @"limit": @0,
                              @"offset": @0,
                              @"page": @0,
                              @"page_size": @0,
                              @"search_for": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/accounts/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/accounts/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/accounts/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'email' => '',
    'institution_user_id' => '',
    'is_active' => 0,
    'limit' => 0,
    'offset' => 0,
    'page' => 0,
    'page_size' => 0,
    'search_for' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/institution/accounts/search', [
  'body' => '{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/accounts/search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => '',
  'institution_user_id' => '',
  'is_active' => 0,
  'limit' => 0,
  'offset' => 0,
  'page' => 0,
  'page_size' => 0,
  'search_for' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'email' => '',
  'institution_user_id' => '',
  'is_active' => 0,
  'limit' => 0,
  'offset' => 0,
  'page' => 0,
  'page_size' => 0,
  'search_for' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/institution/accounts/search');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/accounts/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/accounts/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/institution/accounts/search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/accounts/search"

payload = {
    "email": "",
    "institution_user_id": "",
    "is_active": 0,
    "limit": 0,
    "offset": 0,
    "page": 0,
    "page_size": 0,
    "search_for": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/accounts/search"

payload <- "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/accounts/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/institution/accounts/search') do |req|
  req.body = "{\n  \"email\": \"\",\n  \"institution_user_id\": \"\",\n  \"is_active\": 0,\n  \"limit\": 0,\n  \"offset\": 0,\n  \"page\": 0,\n  \"page_size\": 0,\n  \"search_for\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/accounts/search";

    let payload = json!({
        "email": "",
        "institution_user_id": "",
        "is_active": 0,
        "limit": 0,
        "offset": 0,
        "page": 0,
        "page_size": 0,
        "search_for": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/institution/accounts/search \
  --header 'content-type: application/json' \
  --data '{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}'

echo '{
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
}' |  \
  http POST {{baseUrl}}/account/institution/accounts/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "",\n  "institution_user_id": "",\n  "is_active": 0,\n  "limit": 0,\n  "offset": 0,\n  "page": 0,\n  "page_size": 0,\n  "search_for": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/institution/accounts/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "email": "",
  "institution_user_id": "",
  "is_active": 0,
  "limit": 0,
  "offset": 0,
  "page": 0,
  "page_size": 0,
  "search_for": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/accounts/search")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "active": 0,
    "email": "user@domain.com",
    "first_name": "Doe",
    "id": 1495682,
    "institution_id": 1,
    "institution_user_id": 1,
    "last_name": "John",
    "orcid_id": "0000-0001-2345-6789",
    "quota": 1074000000,
    "used_quota": 1074000000,
    "user_id": 1000001
  }
]

GET Private Account Institution Accounts

{{baseUrl}}/account/institution/accounts

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/accounts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/accounts")

require "http/client"

url = "{{baseUrl}}/account/institution/accounts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/accounts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/accounts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/accounts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/accounts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/accounts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/accounts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/accounts")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/accounts');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/accounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/accounts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/accounts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/accounts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/accounts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/accounts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/accounts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/accounts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/accounts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/accounts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/accounts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/accounts');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/accounts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/accounts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/accounts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/accounts' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/accounts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/accounts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/accounts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/accounts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/accounts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/accounts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/accounts

http GET {{baseUrl}}/account/institution/accounts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/accounts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/accounts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "active": 0,
    "email": "user@domain.com",
    "first_name": "Doe",
    "id": 1495682,
    "institution_id": 1,
    "institution_user_id": 1,
    "last_name": "John",
    "orcid_id": "0000-0001-2345-6789",
    "quota": 1074000000,
    "used_quota": 1074000000,
    "user_id": 1000001
  }
]

GET Private Account Institution Group Embargo Options

{{baseUrl}}/account/institution/groups/:group_id/embargo_options

QUERY PARAMS

group_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/groups/:group_id/embargo_options");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/groups/:group_id/embargo_options")

require "http/client"

url = "{{baseUrl}}/account/institution/groups/:group_id/embargo_options"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/groups/:group_id/embargo_options"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/groups/:group_id/embargo_options");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/groups/:group_id/embargo_options"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/groups/:group_id/embargo_options HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/groups/:group_id/embargo_options")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/groups/:group_id/embargo_options"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/groups/:group_id/embargo_options")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/groups/:group_id/embargo_options")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/groups/:group_id/embargo_options');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/groups/:group_id/embargo_options'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/groups/:group_id/embargo_options';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/groups/:group_id/embargo_options',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/groups/:group_id/embargo_options")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/groups/:group_id/embargo_options',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/groups/:group_id/embargo_options'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/groups/:group_id/embargo_options');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/groups/:group_id/embargo_options'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/groups/:group_id/embargo_options';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/groups/:group_id/embargo_options"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/groups/:group_id/embargo_options" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/groups/:group_id/embargo_options",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/groups/:group_id/embargo_options');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/groups/:group_id/embargo_options');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/groups/:group_id/embargo_options');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/groups/:group_id/embargo_options' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/groups/:group_id/embargo_options' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/groups/:group_id/embargo_options")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/groups/:group_id/embargo_options"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/groups/:group_id/embargo_options"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/groups/:group_id/embargo_options")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/groups/:group_id/embargo_options') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/groups/:group_id/embargo_options";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/groups/:group_id/embargo_options

http GET {{baseUrl}}/account/institution/groups/:group_id/embargo_options

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/groups/:group_id/embargo_options

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/groups/:group_id/embargo_options")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": 364,
    "ip_name": "Figshare IP range",
    "type": "ip_range"
  }
]

GET Private Account Institution Groups

{{baseUrl}}/account/institution/groups

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/groups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/groups")

require "http/client"

url = "{{baseUrl}}/account/institution/groups"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/groups"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/groups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/groups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/groups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/groups")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/groups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/groups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/groups',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/groups'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/groups');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/groups');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/groups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/groups' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/groups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/groups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/groups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/groups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/groups

http GET {{baseUrl}}/account/institution/groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "association_criteria": "IT",
    "id": 1,
    "name": "Materials",
    "parent_id": 0,
    "resource_id": ""
  }
]

GET Private Account Institution Roles

{{baseUrl}}/account/institution/roles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/roles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/roles")

require "http/client"

url = "{{baseUrl}}/account/institution/roles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/roles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/roles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/roles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/roles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/roles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/roles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/roles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/roles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/roles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/roles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/roles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/roles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/roles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/roles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/roles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/roles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/roles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/roles');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/roles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/roles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/roles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/roles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/roles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/roles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/roles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/roles

http GET {{baseUrl}}/account/institution/roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "category": "group",
    "id": 1,
    "name": "Curator"
  }
]

GET Private Account Institution User

{{baseUrl}}/account/institution/users/:account_id

QUERY PARAMS

account_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/users/:account_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/users/:account_id")

require "http/client"

url = "{{baseUrl}}/account/institution/users/:account_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/users/:account_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/users/:account_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/users/:account_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/users/:account_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/users/:account_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/users/:account_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/users/:account_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/users/:account_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/users/:account_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/users/:account_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/users/:account_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/users/:account_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/users/:account_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/users/:account_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/users/:account_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/users/:account_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/users/:account_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/users/:account_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/users/:account_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/users/:account_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/users/:account_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/users/:account_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/users/:account_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/users/:account_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/users/:account_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/users/:account_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/users/:account_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/users/:account_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/users/:account_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/users/:account_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/users/:account_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/users/:account_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/users/:account_id

http GET {{baseUrl}}/account/institution/users/:account_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/users/:account_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/users/:account_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "first_name": "Doe",
  "id": 1495682,
  "is_active": true,
  "is_public": true,
  "job_title": "programmer",
  "last_name": "John",
  "name": "John Doe",
  "orcid_id": "1234-5678-9123-1234",
  "url_name": "John_Doe"
}

GET Private Account Institution embargo options

{{baseUrl}}/account/institution/embargo_options

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/embargo_options");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/embargo_options")

require "http/client"

url = "{{baseUrl}}/account/institution/embargo_options"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/embargo_options"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/embargo_options");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/embargo_options"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/embargo_options HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/embargo_options")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/embargo_options"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/embargo_options")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/embargo_options")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/embargo_options');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/embargo_options'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/embargo_options';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/embargo_options',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/embargo_options")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/embargo_options',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/embargo_options'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/embargo_options');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/embargo_options'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/embargo_options';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/embargo_options"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/embargo_options" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/embargo_options",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/embargo_options');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/embargo_options');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/embargo_options');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/embargo_options' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/embargo_options' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/embargo_options")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/embargo_options"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/embargo_options"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/embargo_options")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/embargo_options') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/embargo_options";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/embargo_options

http GET {{baseUrl}}/account/institution/embargo_options

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/embargo_options

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/embargo_options")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": 364,
    "ip_name": "Figshare IP range",
    "type": "ip_range"
  }
]

GET Private Account Institutions

{{baseUrl}}/account/institution

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution")

require "http/client"

url = "{{baseUrl}}/account/institution"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/institution'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/institution'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/institution'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution

http GET {{baseUrl}}/account/institution

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "domain": null,
  "id": 0,
  "name": "Institution"
}

GET Private Institution Articles

{{baseUrl}}/account/institution/articles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/articles")

require "http/client"

url = "{{baseUrl}}/account/institution/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/articles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/articles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/articles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/articles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/articles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/institution/articles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/articles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/articles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/articles

http GET {{baseUrl}}/account/institution/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "defined_type": 3,
    "defined_type_name": "media",
    "doi": "10.6084/m9.figshare.1434614",
    "group_id": 1234,
    "handle": "111184/figshare.1234",
    "id": 1434614,
    "published_date": "2015-12-31T23:59:59.000Z",
    "thumb": "https://ndownloader.figshare.com/files/123456789/preview/12345678/thumb.png",
    "title": "Test article title",
    "url": "http://api.figshare.com/articles/1434614",
    "url_private_api": "https://api.figshare.com/account/articles/1434614",
    "url_private_html": "https://figshare.com/account/articles/1434614",
    "url_public_api": "https://api.figshare.com/articles/1434614",
    "url_public_html": "https://figshare.com/articles/media/Test_article_title/1434614"
  }
]

POST Private Institution HRfeed Upload

{{baseUrl}}/institution/hrfeed/upload

BODY multipartForm

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/institution/hrfeed/upload");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/institution/hrfeed/upload" {:multipart [{:name "hrfeed"
                                                                                   :content ""}]})

require "http/client"

url = "{{baseUrl}}/institution/hrfeed/upload"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/institution/hrfeed/upload"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "hrfeed",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/institution/hrfeed/upload");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/institution/hrfeed/upload"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/institution/hrfeed/upload HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 115

-----011000010111000001101001
Content-Disposition: form-data; name="hrfeed"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/institution/hrfeed/upload")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/institution/hrfeed/upload"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/institution/hrfeed/upload")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/institution/hrfeed/upload")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('hrfeed', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/institution/hrfeed/upload');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('hrfeed', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/institution/hrfeed/upload',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/institution/hrfeed/upload';
const form = new FormData();
form.append('hrfeed', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const form = new FormData();
form.append('hrfeed', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/institution/hrfeed/upload',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/institution/hrfeed/upload")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/institution/hrfeed/upload',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write('-----011000010111000001101001\r\nContent-Disposition: form-data; name="hrfeed"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/institution/hrfeed/upload',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {hrfeed: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/institution/hrfeed/upload');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/institution/hrfeed/upload',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="hrfeed"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('hrfeed', '');

const url = '{{baseUrl}}/institution/hrfeed/upload';
const options = {method: 'POST'};
options.body = formData;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"hrfeed", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/institution/hrfeed/upload"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/institution/hrfeed/upload" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/institution/hrfeed/upload",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/institution/hrfeed/upload', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/institution/hrfeed/upload');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="hrfeed"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/institution/hrfeed/upload');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/institution/hrfeed/upload' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="hrfeed"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/institution/hrfeed/upload' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="hrfeed"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/institution/hrfeed/upload", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/institution/hrfeed/upload"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/institution/hrfeed/upload"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/institution/hrfeed/upload")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/institution/hrfeed/upload') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"hrfeed\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/institution/hrfeed/upload";

    let form = reqwest::multipart::Form::new()
        .text("hrfeed", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/institution/hrfeed/upload \
  --header 'content-type: multipart/form-data' \
  --form hrfeed=

echo '-----011000010111000001101001
Content-Disposition: form-data; name="hrfeed"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/institution/hrfeed/upload \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'

wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="hrfeed"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/institution/hrfeed/upload

import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "hrfeed",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/institution/hrfeed/upload")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "message": "Project 1 has been published"
}

GET Private account institution group custom fields

{{baseUrl}}/account/institution/custom_fields

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/custom_fields");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/institution/custom_fields")

require "http/client"

url = "{{baseUrl}}/account/institution/custom_fields"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/institution/custom_fields"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/custom_fields");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/custom_fields"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/institution/custom_fields HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/institution/custom_fields")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/custom_fields"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/custom_fields")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/institution/custom_fields")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/institution/custom_fields');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/custom_fields'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/custom_fields';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/custom_fields',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/custom_fields")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/custom_fields',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/custom_fields'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/institution/custom_fields');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/institution/custom_fields'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/custom_fields';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/custom_fields"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/custom_fields" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/custom_fields",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/institution/custom_fields');

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/custom_fields');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/institution/custom_fields');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/custom_fields' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/custom_fields' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/institution/custom_fields")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/custom_fields"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/custom_fields"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/custom_fields")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/institution/custom_fields') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/custom_fields";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/institution/custom_fields

http GET {{baseUrl}}/account/institution/custom_fields

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/institution/custom_fields

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/custom_fields")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "field_type": "textarea",
    "id": 365,
    "name": "my custom field"
  }
]

GET Public Licenses (GET)

{{baseUrl}}/institutions/:institution_string_id/articles/filter-by

QUERY PARAMS

resource_id

filename

institution_string_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by" {:query-params {:resource_id ""
                                                                                                                 :filename ""}})

require "http/client"

url = "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/institutions/:institution_string_id/articles/filter-by?resource_id=&filename= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by',
  params: {resource_id: '', filename: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by',
  qs: {resource_id: '', filename: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by');

req.query({
  resource_id: '',
  filename: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by',
  params: {resource_id: '', filename: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=');

echo $response->getBody();

setUrl('{{baseUrl}}/institutions/:institution_string_id/articles/filter-by');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resource_id' => '',
  'filename' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/institutions/:institution_string_id/articles/filter-by');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resource_id' => '',
  'filename' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by"

querystring = {"resource_id":"","filename":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by"

queryString <- list(
  resource_id = "",
  filename = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/institutions/:institution_string_id/articles/filter-by') do |req|
  req.params['resource_id'] = ''
  req.params['filename'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by";

    let querystring = [
        ("resource_id", ""),
        ("filename", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename='

http GET '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/institutions/:institution_string_id/articles/filter-by?resource_id=&filename=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "defined_type": 3,
    "defined_type_name": "media",
    "doi": "10.6084/m9.figshare.1434614",
    "group_id": 1234,
    "handle": "111184/figshare.1234",
    "id": 1434614,
    "published_date": "2015-12-31T23:59:59.000Z",
    "thumb": "https://ndownloader.figshare.com/files/123456789/preview/12345678/thumb.png",
    "title": "Test article title",
    "url": "http://api.figshare.com/articles/1434614",
    "url_private_api": "https://api.figshare.com/account/articles/1434614",
    "url_private_html": "https://figshare.com/account/articles/1434614",
    "url_public_api": "https://api.figshare.com/articles/1434614",
    "url_public_html": "https://figshare.com/articles/media/Test_article_title/1434614"
  }
]

PUT Update Institution Account

{{baseUrl}}/account/institution/accounts/:account_id

QUERY PARAMS

account_id

BODY json

{
  "group_id": 0,
  "is_active": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/institution/accounts/:account_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"group_id\": 0,\n  \"is_active\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/institution/accounts/:account_id" {:content-type :json
                                                                                    :form-params {:group_id 0
                                                                                                  :is_active false}})

require "http/client"

url = "{{baseUrl}}/account/institution/accounts/:account_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"group_id\": 0,\n  \"is_active\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/institution/accounts/:account_id"),
    Content = new StringContent("{\n  \"group_id\": 0,\n  \"is_active\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/institution/accounts/:account_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"group_id\": 0,\n  \"is_active\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/institution/accounts/:account_id"

	payload := strings.NewReader("{\n  \"group_id\": 0,\n  \"is_active\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/account/institution/accounts/:account_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "group_id": 0,
  "is_active": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/institution/accounts/:account_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"group_id\": 0,\n  \"is_active\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/institution/accounts/:account_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"group_id\": 0,\n  \"is_active\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"group_id\": 0,\n  \"is_active\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts/:account_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/institution/accounts/:account_id")
  .header("content-type", "application/json")
  .body("{\n  \"group_id\": 0,\n  \"is_active\": false\n}")
  .asString();

const data = JSON.stringify({
  group_id: 0,
  is_active: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/institution/accounts/:account_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/institution/accounts/:account_id',
  headers: {'content-type': 'application/json'},
  data: {group_id: 0, is_active: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/institution/accounts/:account_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"group_id":0,"is_active":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/institution/accounts/:account_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "group_id": 0,\n  "is_active": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"group_id\": 0,\n  \"is_active\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/institution/accounts/:account_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/institution/accounts/:account_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({group_id: 0, is_active: false}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/institution/accounts/:account_id',
  headers: {'content-type': 'application/json'},
  body: {group_id: 0, is_active: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/institution/accounts/:account_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  group_id: 0,
  is_active: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/institution/accounts/:account_id',
  headers: {'content-type': 'application/json'},
  data: {group_id: 0, is_active: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/institution/accounts/:account_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"group_id":0,"is_active":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"group_id": @0,
                              @"is_active": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/institution/accounts/:account_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/institution/accounts/:account_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"group_id\": 0,\n  \"is_active\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/institution/accounts/:account_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'group_id' => 0,
    'is_active' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/institution/accounts/:account_id', [
  'body' => '{
  "group_id": 0,
  "is_active": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/institution/accounts/:account_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'group_id' => 0,
  'is_active' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'group_id' => 0,
  'is_active' => null
]));
$request->setRequestUrl('{{baseUrl}}/account/institution/accounts/:account_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/institution/accounts/:account_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "group_id": 0,
  "is_active": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/institution/accounts/:account_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "group_id": 0,
  "is_active": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"group_id\": 0,\n  \"is_active\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/institution/accounts/:account_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/institution/accounts/:account_id"

payload = {
    "group_id": 0,
    "is_active": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/institution/accounts/:account_id"

payload <- "{\n  \"group_id\": 0,\n  \"is_active\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/institution/accounts/:account_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"group_id\": 0,\n  \"is_active\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/institution/accounts/:account_id') do |req|
  req.body = "{\n  \"group_id\": 0,\n  \"is_active\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/institution/accounts/:account_id";

    let payload = json!({
        "group_id": 0,
        "is_active": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/institution/accounts/:account_id \
  --header 'content-type: application/json' \
  --data '{
  "group_id": 0,
  "is_active": false
}'

echo '{
  "group_id": 0,
  "is_active": false
}' |  \
  http PUT {{baseUrl}}/account/institution/accounts/:account_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "group_id": 0,\n  "is_active": false\n}' \
  --output-document \
  - {{baseUrl}}/account/institution/accounts/:account_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "group_id": 0,
  "is_active": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/institution/accounts/:account_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

GET Item Types

{{baseUrl}}/item_types

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/item_types");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/item_types")

require "http/client"

url = "{{baseUrl}}/item_types"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/item_types"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/item_types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/item_types"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/item_types HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/item_types")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/item_types"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/item_types")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/item_types")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/item_types');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/item_types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/item_types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/item_types',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/item_types")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/item_types',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/item_types'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/item_types');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/item_types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/item_types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/item_types"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/item_types" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/item_types",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/item_types');

echo $response->getBody();

setUrl('{{baseUrl}}/item_types');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/item_types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/item_types' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/item_types' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/item_types")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/item_types"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/item_types"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/item_types")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/item_types') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/item_types";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/item_types

http GET {{baseUrl}}/item_types

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/item_types

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/item_types")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "icon": "paper",
    "is_selectable": true,
    "name": "journal contribution",
    "public_description": "This is the description of an item type",
    "string_id": "journal_contribution",
    "url_name": "journal_contribution"
  }
]

GET Private Account Licenses

{{baseUrl}}/account/licenses

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/licenses");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/licenses")

require "http/client"

url = "{{baseUrl}}/account/licenses"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/licenses"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/licenses");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/licenses"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/licenses HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/licenses")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/licenses"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/licenses")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/licenses")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/licenses');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/licenses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/licenses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/licenses',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/licenses")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/licenses',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/licenses'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/licenses');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/licenses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/licenses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/licenses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/licenses" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/licenses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/licenses');

echo $response->getBody();

setUrl('{{baseUrl}}/account/licenses');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/licenses');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/licenses' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/licenses' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/licenses")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/licenses"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/licenses"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/licenses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/licenses') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/licenses";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/licenses

http GET {{baseUrl}}/account/licenses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/licenses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/licenses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "name": "CC BY",
    "url": "http://creativecommons.org/licenses/by/4.0/",
    "value": 1
  }
]

GET Private Account information

{{baseUrl}}/account

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account")

require "http/client"

url = "{{baseUrl}}/account"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account');

echo $response->getBody();

setUrl('{{baseUrl}}/account');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account

http GET {{baseUrl}}/account

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "active": 0,
  "created_date": "2018-05-22T04:04:04",
  "email": "user@domain.com",
  "first_name": "Doe",
  "group_id": 0,
  "id": 1495682,
  "institution_id": 1,
  "institution_user_id": "djohn42",
  "last_name": "John",
  "maximum_file_size": 0,
  "modified_date": "2018-05-22T04:04:04",
  "pending_quota_request": true,
  "quota": 0,
  "used_quota": 0,
  "used_quota_private": 0,
  "used_quota_public": 0
}

GET Public Categories

{{baseUrl}}/categories

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/categories")

require "http/client"

url = "{{baseUrl}}/categories"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/categories"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/categories")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/categories');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/categories'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/categories');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/categories

http GET {{baseUrl}}/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Public File Download

{{baseUrl}}/file/download/:file_id

QUERY PARAMS

file_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/file/download/:file_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/file/download/:file_id")

require "http/client"

url = "{{baseUrl}}/file/download/:file_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/file/download/:file_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/file/download/:file_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/file/download/:file_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/file/download/:file_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/file/download/:file_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/file/download/:file_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/file/download/:file_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/file/download/:file_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/file/download/:file_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/file/download/:file_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/file/download/:file_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/file/download/:file_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/file/download/:file_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/file/download/:file_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/file/download/:file_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/file/download/:file_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/file/download/:file_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/file/download/:file_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/file/download/:file_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/file/download/:file_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/file/download/:file_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/file/download/:file_id');

echo $response->getBody();

setUrl('{{baseUrl}}/file/download/:file_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/file/download/:file_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/file/download/:file_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/file/download/:file_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/file/download/:file_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/file/download/:file_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/file/download/:file_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/file/download/:file_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/file/download/:file_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/file/download/:file_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/file/download/:file_id

http GET {{baseUrl}}/file/download/:file_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/file/download/:file_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/file/download/:file_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Public Licenses

{{baseUrl}}/licenses

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/licenses");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/licenses")

require "http/client"

url = "{{baseUrl}}/licenses"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/licenses"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/licenses");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/licenses"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/licenses HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/licenses")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/licenses"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/licenses")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/licenses")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/licenses');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/licenses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/licenses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/licenses',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/licenses")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/licenses',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/licenses'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/licenses');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/licenses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/licenses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/licenses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/licenses" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/licenses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/licenses');

echo $response->getBody();

setUrl('{{baseUrl}}/licenses');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/licenses');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/licenses' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/licenses' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/licenses")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/licenses"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/licenses"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/licenses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/licenses') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/licenses";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/licenses

http GET {{baseUrl}}/licenses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/licenses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/licenses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

POST Search Funding

{{baseUrl}}/account/funding/search

BODY json

{
  "search_for": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/funding/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"search_for\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/funding/search" {:content-type :json
                                                                   :form-params {:search_for ""}})

require "http/client"

url = "{{baseUrl}}/account/funding/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"search_for\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/funding/search"),
    Content = new StringContent("{\n  \"search_for\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/funding/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"search_for\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/funding/search"

	payload := strings.NewReader("{\n  \"search_for\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/funding/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "search_for": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/funding/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"search_for\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/funding/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"search_for\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"search_for\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/funding/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/funding/search")
  .header("content-type", "application/json")
  .body("{\n  \"search_for\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  search_for: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/funding/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/funding/search',
  headers: {'content-type': 'application/json'},
  data: {search_for: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/funding/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"search_for":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/funding/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "search_for": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"search_for\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/funding/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/funding/search',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({search_for: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/funding/search',
  headers: {'content-type': 'application/json'},
  body: {search_for: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/funding/search');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  search_for: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/funding/search',
  headers: {'content-type': 'application/json'},
  data: {search_for: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/funding/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"search_for":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"search_for": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/funding/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/funding/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"search_for\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/funding/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'search_for' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/funding/search', [
  'body' => '{
  "search_for": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/funding/search');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'search_for' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'search_for' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/funding/search');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/funding/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "search_for": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/funding/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "search_for": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"search_for\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/funding/search", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/funding/search"

payload = { "search_for": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/funding/search"

payload <- "{\n  \"search_for\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/funding/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"search_for\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/funding/search') do |req|
  req.body = "{\n  \"search_for\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/funding/search";

    let payload = json!({"search_for": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/funding/search \
  --header 'content-type: application/json' \
  --data '{
  "search_for": ""
}'

echo '{
  "search_for": ""
}' |  \
  http POST {{baseUrl}}/account/funding/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "search_for": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/funding/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["search_for": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/funding/search")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": 1,
    "title": "Scholarly funding",
    "url": "https://app.dimensions.ai/details/grant/1"
  }
]

POST Create project article

{{baseUrl}}/account/projects/:project_id/articles

BODY json

{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/articles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects/:project_id/articles" {:content-type :json
                                                                                  :form-params {:authors [{}]
                                                                                                :categories []
                                                                                                :categories_by_source_id []
                                                                                                :custom_fields {}
                                                                                                :custom_fields_list [{:name ""
                                                                                                                      :value ""}]
                                                                                                :defined_type ""
                                                                                                :description ""
                                                                                                :doi ""
                                                                                                :funding ""
                                                                                                :funding_list [{:id 0
                                                                                                                :title ""}]
                                                                                                :handle ""
                                                                                                :keywords []
                                                                                                :license 0
                                                                                                :references []
                                                                                                :resource_doi ""
                                                                                                :resource_title ""
                                                                                                :tags []
                                                                                                :timeline {:firstOnline ""
                                                                                                           :publisherAcceptance ""
                                                                                                           :publisherPublication ""}
                                                                                                :title ""}})

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/articles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/articles"),
    Content = new StringContent("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/articles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/articles"

	payload := strings.NewReader("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/projects/:project_id/articles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 578

{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects/:project_id/articles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/articles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects/:project_id/articles")
  .header("content-type", "application/json")
  .body("{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authors: [
    {}
  ],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  defined_type: '',
  description: '',
  doi: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  handle: '',
  keywords: [],
  license: 0,
  references: [],
  resource_doi: '',
  resource_title: '',
  tags: [],
  timeline: {
    firstOnline: '',
    publisherAcceptance: '',
    publisherPublication: ''
  },
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects/:project_id/articles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/articles',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    defined_type: '',
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    handle: '',
    keywords: [],
    license: 0,
    references: [],
    resource_doi: '',
    resource_title: '',
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/articles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{}],"categories":[],"categories_by_source_id":[],"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"defined_type":"","description":"","doi":"","funding":"","funding_list":[{"id":0,"title":""}],"handle":"","keywords":[],"license":0,"references":[],"resource_doi":"","resource_title":"","tags":[],"timeline":{"firstOnline":"","publisherAcceptance":"","publisherPublication":""},"title":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/articles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authors": [\n    {}\n  ],\n  "categories": [],\n  "categories_by_source_id": [],\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "defined_type": "",\n  "description": "",\n  "doi": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "handle": "",\n  "keywords": [],\n  "license": 0,\n  "references": [],\n  "resource_doi": "",\n  "resource_title": "",\n  "tags": [],\n  "timeline": {\n    "firstOnline": "",\n    "publisherAcceptance": "",\n    "publisherPublication": ""\n  },\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/articles',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  authors: [{}],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [{name: '', value: ''}],
  defined_type: '',
  description: '',
  doi: '',
  funding: '',
  funding_list: [{id: 0, title: ''}],
  handle: '',
  keywords: [],
  license: 0,
  references: [],
  resource_doi: '',
  resource_title: '',
  tags: [],
  timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/articles',
  headers: {'content-type': 'application/json'},
  body: {
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    defined_type: '',
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    handle: '',
    keywords: [],
    license: 0,
    references: [],
    resource_doi: '',
    resource_title: '',
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects/:project_id/articles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authors: [
    {}
  ],
  categories: [],
  categories_by_source_id: [],
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  defined_type: '',
  description: '',
  doi: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  handle: '',
  keywords: [],
  license: 0,
  references: [],
  resource_doi: '',
  resource_title: '',
  tags: [],
  timeline: {
    firstOnline: '',
    publisherAcceptance: '',
    publisherPublication: ''
  },
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/articles',
  headers: {'content-type': 'application/json'},
  data: {
    authors: [{}],
    categories: [],
    categories_by_source_id: [],
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    defined_type: '',
    description: '',
    doi: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    handle: '',
    keywords: [],
    license: 0,
    references: [],
    resource_doi: '',
    resource_title: '',
    tags: [],
    timeline: {firstOnline: '', publisherAcceptance: '', publisherPublication: ''},
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/articles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authors":[{}],"categories":[],"categories_by_source_id":[],"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"defined_type":"","description":"","doi":"","funding":"","funding_list":[{"id":0,"title":""}],"handle":"","keywords":[],"license":0,"references":[],"resource_doi":"","resource_title":"","tags":[],"timeline":{"firstOnline":"","publisherAcceptance":"","publisherPublication":""},"title":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authors": @[ @{  } ],
                              @"categories": @[  ],
                              @"categories_by_source_id": @[  ],
                              @"custom_fields": @{  },
                              @"custom_fields_list": @[ @{ @"name": @"", @"value": @"" } ],
                              @"defined_type": @"",
                              @"description": @"",
                              @"doi": @"",
                              @"funding": @"",
                              @"funding_list": @[ @{ @"id": @0, @"title": @"" } ],
                              @"handle": @"",
                              @"keywords": @[  ],
                              @"license": @0,
                              @"references": @[  ],
                              @"resource_doi": @"",
                              @"resource_title": @"",
                              @"tags": @[  ],
                              @"timeline": @{ @"firstOnline": @"", @"publisherAcceptance": @"", @"publisherPublication": @"" },
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/articles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authors' => [
        [
                
        ]
    ],
    'categories' => [
        
    ],
    'categories_by_source_id' => [
        
    ],
    'custom_fields' => [
        
    ],
    'custom_fields_list' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'defined_type' => '',
    'description' => '',
    'doi' => '',
    'funding' => '',
    'funding_list' => [
        [
                'id' => 0,
                'title' => ''
        ]
    ],
    'handle' => '',
    'keywords' => [
        
    ],
    'license' => 0,
    'references' => [
        
    ],
    'resource_doi' => '',
    'resource_title' => '',
    'tags' => [
        
    ],
    'timeline' => [
        'firstOnline' => '',
        'publisherAcceptance' => '',
        'publisherPublication' => ''
    ],
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects/:project_id/articles', [
  'body' => '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/articles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authors' => [
    [
        
    ]
  ],
  'categories' => [
    
  ],
  'categories_by_source_id' => [
    
  ],
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'defined_type' => '',
  'description' => '',
  'doi' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'handle' => '',
  'keywords' => [
    
  ],
  'license' => 0,
  'references' => [
    
  ],
  'resource_doi' => '',
  'resource_title' => '',
  'tags' => [
    
  ],
  'timeline' => [
    'firstOnline' => '',
    'publisherAcceptance' => '',
    'publisherPublication' => ''
  ],
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authors' => [
    [
        
    ]
  ],
  'categories' => [
    
  ],
  'categories_by_source_id' => [
    
  ],
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'defined_type' => '',
  'description' => '',
  'doi' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'handle' => '',
  'keywords' => [
    
  ],
  'license' => 0,
  'references' => [
    
  ],
  'resource_doi' => '',
  'resource_title' => '',
  'tags' => [
    
  ],
  'timeline' => [
    'firstOnline' => '',
    'publisherAcceptance' => '',
    'publisherPublication' => ''
  ],
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/projects/:project_id/articles');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/articles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/articles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/projects/:project_id/articles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/articles"

payload = {
    "authors": [{}],
    "categories": [],
    "categories_by_source_id": [],
    "custom_fields": {},
    "custom_fields_list": [
        {
            "name": "",
            "value": ""
        }
    ],
    "defined_type": "",
    "description": "",
    "doi": "",
    "funding": "",
    "funding_list": [
        {
            "id": 0,
            "title": ""
        }
    ],
    "handle": "",
    "keywords": [],
    "license": 0,
    "references": [],
    "resource_doi": "",
    "resource_title": "",
    "tags": [],
    "timeline": {
        "firstOnline": "",
        "publisherAcceptance": "",
        "publisherPublication": ""
    },
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/articles"

payload <- "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/articles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/projects/:project_id/articles') do |req|
  req.body = "{\n  \"authors\": [\n    {}\n  ],\n  \"categories\": [],\n  \"categories_by_source_id\": [],\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"defined_type\": \"\",\n  \"description\": \"\",\n  \"doi\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"handle\": \"\",\n  \"keywords\": [],\n  \"license\": 0,\n  \"references\": [],\n  \"resource_doi\": \"\",\n  \"resource_title\": \"\",\n  \"tags\": [],\n  \"timeline\": {\n    \"firstOnline\": \"\",\n    \"publisherAcceptance\": \"\",\n    \"publisherPublication\": \"\"\n  },\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/articles";

    let payload = json!({
        "authors": (json!({})),
        "categories": (),
        "categories_by_source_id": (),
        "custom_fields": json!({}),
        "custom_fields_list": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "defined_type": "",
        "description": "",
        "doi": "",
        "funding": "",
        "funding_list": (
            json!({
                "id": 0,
                "title": ""
            })
        ),
        "handle": "",
        "keywords": (),
        "license": 0,
        "references": (),
        "resource_doi": "",
        "resource_title": "",
        "tags": (),
        "timeline": json!({
            "firstOnline": "",
            "publisherAcceptance": "",
            "publisherPublication": ""
        }),
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects/:project_id/articles \
  --header 'content-type: application/json' \
  --data '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}'

echo '{
  "authors": [
    {}
  ],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": {
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  },
  "title": ""
}' |  \
  http POST {{baseUrl}}/account/projects/:project_id/articles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authors": [\n    {}\n  ],\n  "categories": [],\n  "categories_by_source_id": [],\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "defined_type": "",\n  "description": "",\n  "doi": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "handle": "",\n  "keywords": [],\n  "license": 0,\n  "references": [],\n  "resource_doi": "",\n  "resource_title": "",\n  "tags": [],\n  "timeline": {\n    "firstOnline": "",\n    "publisherAcceptance": "",\n    "publisherPublication": ""\n  },\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/articles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authors": [[]],
  "categories": [],
  "categories_by_source_id": [],
  "custom_fields": [],
  "custom_fields_list": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "defined_type": "",
  "description": "",
  "doi": "",
  "funding": "",
  "funding_list": [
    [
      "id": 0,
      "title": ""
    ]
  ],
  "handle": "",
  "keywords": [],
  "license": 0,
  "references": [],
  "resource_doi": "",
  "resource_title": "",
  "tags": [],
  "timeline": [
    "firstOnline": "",
    "publisherAcceptance": "",
    "publisherPublication": ""
  ],
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/articles")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "entity_id": 33334444
}

POST Create project note

{{baseUrl}}/account/projects/:project_id/notes

BODY json

{
  "text": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/notes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"text\": \"note to remember\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects/:project_id/notes" {:content-type :json
                                                                               :form-params {:text "note to remember"}})

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/notes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"text\": \"note to remember\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/notes"),
    Content = new StringContent("{\n  \"text\": \"note to remember\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/notes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"text\": \"note to remember\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/notes"

	payload := strings.NewReader("{\n  \"text\": \"note to remember\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/projects/:project_id/notes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "text": "note to remember"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects/:project_id/notes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"text\": \"note to remember\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/notes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"text\": \"note to remember\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"text\": \"note to remember\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects/:project_id/notes")
  .header("content-type", "application/json")
  .body("{\n  \"text\": \"note to remember\"\n}")
  .asString();

const data = JSON.stringify({
  text: 'note to remember'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects/:project_id/notes');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/notes',
  headers: {'content-type': 'application/json'},
  data: {text: 'note to remember'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/notes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"text":"note to remember"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/notes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "text": "note to remember"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"text\": \"note to remember\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/notes',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({text: 'note to remember'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/notes',
  headers: {'content-type': 'application/json'},
  body: {text: 'note to remember'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects/:project_id/notes');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  text: 'note to remember'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/notes',
  headers: {'content-type': 'application/json'},
  data: {text: 'note to remember'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/notes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"text":"note to remember"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"text": @"note to remember" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/notes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/notes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"text\": \"note to remember\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/notes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'text' => 'note to remember'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects/:project_id/notes', [
  'body' => '{
  "text": "note to remember"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/notes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'text' => 'note to remember'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'text' => 'note to remember'
]));
$request->setRequestUrl('{{baseUrl}}/account/projects/:project_id/notes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/notes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "text": "note to remember"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/notes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "text": "note to remember"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"text\": \"note to remember\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/projects/:project_id/notes", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/notes"

payload = { "text": "note to remember" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/notes"

payload <- "{\n  \"text\": \"note to remember\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/notes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"text\": \"note to remember\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/projects/:project_id/notes') do |req|
  req.body = "{\n  \"text\": \"note to remember\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/notes";

    let payload = json!({"text": "note to remember"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects/:project_id/notes \
  --header 'content-type: application/json' \
  --data '{
  "text": "note to remember"
}'

echo '{
  "text": "note to remember"
}' |  \
  http POST {{baseUrl}}/account/projects/:project_id/notes \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "text": "note to remember"\n}' \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/notes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["text": "note to remember"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/notes")! 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()

POST Create project

{{baseUrl}}/account/projects

BODY json

{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects" {:content-type :json
                                                             :form-params {:custom_fields {}
                                                                           :custom_fields_list [{:name ""
                                                                                                 :value ""}]
                                                                           :description ""
                                                                           :funding ""
                                                                           :funding_list [{:id 0
                                                                                           :title ""}]
                                                                           :group_id 0
                                                                           :title ""}})

require "http/client"

url = "{{baseUrl}}/account/projects"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects"),
    Content = new StringContent("{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects"

	payload := strings.NewReader("{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/projects HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 244

{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects")
  .header("content-type", "application/json")
  .body("{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  description: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  group_id: 0,
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects',
  headers: {'content-type': 'application/json'},
  data: {
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    description: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"description":"","funding":"","funding_list":[{"id":0,"title":""}],"group_id":0,"title":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "description": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "group_id": 0,\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/projects")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  custom_fields: {},
  custom_fields_list: [{name: '', value: ''}],
  description: '',
  funding: '',
  funding_list: [{id: 0, title: ''}],
  group_id: 0,
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects',
  headers: {'content-type': 'application/json'},
  body: {
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    description: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  custom_fields: {},
  custom_fields_list: [
    {
      name: '',
      value: ''
    }
  ],
  description: '',
  funding: '',
  funding_list: [
    {
      id: 0,
      title: ''
    }
  ],
  group_id: 0,
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects',
  headers: {'content-type': 'application/json'},
  data: {
    custom_fields: {},
    custom_fields_list: [{name: '', value: ''}],
    description: '',
    funding: '',
    funding_list: [{id: 0, title: ''}],
    group_id: 0,
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"custom_fields":{},"custom_fields_list":[{"name":"","value":""}],"description":"","funding":"","funding_list":[{"id":0,"title":""}],"group_id":0,"title":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"custom_fields": @{  },
                              @"custom_fields_list": @[ @{ @"name": @"", @"value": @"" } ],
                              @"description": @"",
                              @"funding": @"",
                              @"funding_list": @[ @{ @"id": @0, @"title": @"" } ],
                              @"group_id": @0,
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'custom_fields' => [
        
    ],
    'custom_fields_list' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'description' => '',
    'funding' => '',
    'funding_list' => [
        [
                'id' => 0,
                'title' => ''
        ]
    ],
    'group_id' => 0,
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects', [
  'body' => '{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'description' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'group_id' => 0,
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'custom_fields' => [
    
  ],
  'custom_fields_list' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'description' => '',
  'funding' => '',
  'funding_list' => [
    [
        'id' => 0,
        'title' => ''
    ]
  ],
  'group_id' => 0,
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/projects');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/projects", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects"

payload = {
    "custom_fields": {},
    "custom_fields_list": [
        {
            "name": "",
            "value": ""
        }
    ],
    "description": "",
    "funding": "",
    "funding_list": [
        {
            "id": 0,
            "title": ""
        }
    ],
    "group_id": 0,
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects"

payload <- "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/projects') do |req|
  req.body = "{\n  \"custom_fields\": {},\n  \"custom_fields_list\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"description\": \"\",\n  \"funding\": \"\",\n  \"funding_list\": [\n    {\n      \"id\": 0,\n      \"title\": \"\"\n    }\n  ],\n  \"group_id\": 0,\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects";

    let payload = json!({
        "custom_fields": json!({}),
        "custom_fields_list": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "description": "",
        "funding": "",
        "funding_list": (
            json!({
                "id": 0,
                "title": ""
            })
        ),
        "group_id": 0,
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects \
  --header 'content-type: application/json' \
  --data '{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}'

echo '{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "group_id": 0,
  "title": ""
}' |  \
  http POST {{baseUrl}}/account/projects \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "custom_fields": {},\n  "custom_fields_list": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "description": "",\n  "funding": "",\n  "funding_list": [\n    {\n      "id": 0,\n      "title": ""\n    }\n  ],\n  "group_id": 0,\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/account/projects

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "custom_fields": [],
  "custom_fields_list": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    [
      "id": 0,
      "title": ""
    ]
  ],
  "group_id": 0,
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "entity_id": 33334444
}

DELETE Delete project article

{{baseUrl}}/account/projects/:project_id/articles/:article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/articles/:article_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/projects/:project_id/articles/:article_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/articles/:article_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/articles/:article_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/account/projects/:project_id/articles/:article_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/articles/:article_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/projects/:project_id/articles/:article_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/articles/:article_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/projects/:project_id/articles/:article_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/articles/:article_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/projects/:project_id/articles/:article_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/projects/:project_id/articles/:article_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/articles/:article_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/projects/:project_id/articles/:article_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/projects/:project_id/articles/:article_id

http DELETE {{baseUrl}}/account/projects/:project_id/articles/:article_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/articles/:article_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

DELETE Delete project note

{{baseUrl}}/account/projects/:project_id/notes/:note_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/notes/:note_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/projects/:project_id/notes/:note_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/notes/:note_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/notes/:note_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/account/projects/:project_id/notes/:note_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/notes/:note_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/notes/:note_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/notes/:note_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/notes/:note_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/notes/:note_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/notes/:note_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/notes/:note_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/notes/:note_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/notes/:note_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/notes/:note_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/notes/:note_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/projects/:project_id/notes/:note_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/notes/:note_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/projects/:project_id/notes/:note_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/projects/:project_id/notes/:note_id

http DELETE {{baseUrl}}/account/projects/:project_id/notes/:note_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/notes/:note_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/notes/:note_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

DELETE Delete project

{{baseUrl}}/account/projects/:project_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/projects/:project_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/account/projects/:project_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/projects/:project_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/projects/:project_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/projects/:project_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/projects/:project_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/projects/:project_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/projects/:project_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/projects/:project_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/projects/:project_id

http DELETE {{baseUrl}}/account/projects/:project_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

POST Invite project collaborators

{{baseUrl}}/account/projects/:project_id/collaborators

BODY json

{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/collaborators");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects/:project_id/collaborators" {:content-type :json
                                                                                       :form-params {:comment ""
                                                                                                     :email ""
                                                                                                     :role_name ""
                                                                                                     :user_id 0}})

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/collaborators"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/collaborators"),
    Content = new StringContent("{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/collaborators");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/collaborators"

	payload := strings.NewReader("{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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))

}

POST /baseUrl/account/projects/:project_id/collaborators HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects/:project_id/collaborators")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/collaborators"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/collaborators")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects/:project_id/collaborators")
  .header("content-type", "application/json")
  .body("{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}")
  .asString();

const data = JSON.stringify({
  comment: '',
  email: '',
  role_name: '',
  user_id: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects/:project_id/collaborators');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators',
  headers: {'content-type': 'application/json'},
  data: {comment: '', email: '', role_name: '', user_id: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/collaborators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"comment":"","email":"","role_name":"","user_id":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/collaborators',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "comment": "",\n  "email": "",\n  "role_name": "",\n  "user_id": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/collaborators")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/collaborators',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({comment: '', email: '', role_name: '', user_id: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators',
  headers: {'content-type': 'application/json'},
  body: {comment: '', email: '', role_name: '', user_id: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects/:project_id/collaborators');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  comment: '',
  email: '',
  role_name: '',
  user_id: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators',
  headers: {'content-type': 'application/json'},
  data: {comment: '', email: '', role_name: '', user_id: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/collaborators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"comment":"","email":"","role_name":"","user_id":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"comment": @"",
                              @"email": @"",
                              @"role_name": @"",
                              @"user_id": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/collaborators"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/collaborators" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/collaborators",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'comment' => '',
    'email' => '',
    'role_name' => '',
    'user_id' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects/:project_id/collaborators', [
  'body' => '{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/collaborators');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'comment' => '',
  'email' => '',
  'role_name' => '',
  'user_id' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'comment' => '',
  'email' => '',
  'role_name' => '',
  'user_id' => 0
]));
$request->setRequestUrl('{{baseUrl}}/account/projects/:project_id/collaborators');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/collaborators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/collaborators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/account/projects/:project_id/collaborators", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/collaborators"

payload = {
    "comment": "",
    "email": "",
    "role_name": "",
    "user_id": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/collaborators"

payload <- "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/collaborators")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/account/projects/:project_id/collaborators') do |req|
  req.body = "{\n  \"comment\": \"\",\n  \"email\": \"\",\n  \"role_name\": \"\",\n  \"user_id\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/collaborators";

    let payload = json!({
        "comment": "",
        "email": "",
        "role_name": "",
        "user_id": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects/:project_id/collaborators \
  --header 'content-type: application/json' \
  --data '{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}'

echo '{
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
}' |  \
  http POST {{baseUrl}}/account/projects/:project_id/collaborators \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "comment": "",\n  "email": "",\n  "role_name": "",\n  "user_id": 0\n}' \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/collaborators

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "comment": "",
  "email": "",
  "role_name": "",
  "user_id": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/collaborators")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "message": "Project 1 has been published"
}

GET List project articles

{{baseUrl}}/account/projects/:project_id/articles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/articles")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/articles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/articles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/articles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/articles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/articles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/articles

http GET {{baseUrl}}/account/projects/:project_id/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "defined_type": 3,
    "defined_type_name": "media",
    "doi": "10.6084/m9.figshare.1434614",
    "group_id": 1234,
    "handle": "111184/figshare.1234",
    "id": 1434614,
    "published_date": "2015-12-31T23:59:59.000Z",
    "thumb": "https://ndownloader.figshare.com/files/123456789/preview/12345678/thumb.png",
    "title": "Test article title",
    "url": "http://api.figshare.com/articles/1434614",
    "url_private_api": "https://api.figshare.com/account/articles/1434614",
    "url_private_html": "https://figshare.com/account/articles/1434614",
    "url_public_api": "https://api.figshare.com/articles/1434614",
    "url_public_html": "https://figshare.com/articles/media/Test_article_title/1434614"
  }
]

GET List project collaborators

{{baseUrl}}/account/projects/:project_id/collaborators

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/collaborators");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/collaborators")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/collaborators"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/collaborators"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/collaborators");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/collaborators"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/collaborators HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/collaborators")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/collaborators"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/collaborators")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/collaborators")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/collaborators');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/collaborators';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/collaborators',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/collaborators")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/collaborators',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/collaborators');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/collaborators';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/collaborators"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/collaborators" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/collaborators",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/collaborators');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/collaborators');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/collaborators');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/collaborators' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/collaborators' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/collaborators")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/collaborators"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/collaborators"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/collaborators")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/collaborators') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/collaborators";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/collaborators

http GET {{baseUrl}}/account/projects/:project_id/collaborators

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/collaborators

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/collaborators")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "name": "name",
    "role_name": "Owner",
    "status": "invited",
    "user_id": 1
  }
]

GET List project notes

{{baseUrl}}/account/projects/:project_id/notes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/notes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/notes")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/notes"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/notes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/notes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/notes"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/notes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/notes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/notes"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/notes")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/notes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/notes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/notes';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/notes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/notes',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/notes'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/notes');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/notes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/notes';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/notes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/notes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/notes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/notes');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/notes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/notes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/notes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/notes' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/notes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/notes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/notes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/notes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/notes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/notes";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/notes

http GET {{baseUrl}}/account/projects/:project_id/notes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/notes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/notes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "abstract": "text",
    "created_date": "2017-05-16T16:49:11Z",
    "id": 1,
    "modified_date": "2017-05-16T16:49:11Z",
    "user_id": 100008,
    "user_name": "user"
  }
]

POST Private Project Leave

{{baseUrl}}/account/projects/:project_id/leave

QUERY PARAMS

project_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/leave");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects/:project_id/leave")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/leave"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/leave"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/leave");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/leave"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/account/projects/:project_id/leave HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects/:project_id/leave")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/leave"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/leave")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects/:project_id/leave")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects/:project_id/leave');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/leave'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/leave';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/leave',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/leave")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/leave',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/leave'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects/:project_id/leave');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/leave'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/leave';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/leave"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/leave" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/leave",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects/:project_id/leave');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/leave');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/leave');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/leave' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/leave' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/projects/:project_id/leave")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/leave"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/leave"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/leave")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/projects/:project_id/leave') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/leave";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects/:project_id/leave

http POST {{baseUrl}}/account/projects/:project_id/leave

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/leave

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/leave")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()

POST Private Project Publish

{{baseUrl}}/account/projects/:project_id/publish

QUERY PARAMS

project_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/publish");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects/:project_id/publish")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/publish"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/publish"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/publish"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/account/projects/:project_id/publish HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects/:project_id/publish")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/publish"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/publish")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects/:project_id/publish")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects/:project_id/publish');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/publish';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/publish',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/publish")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/publish',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/publish'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects/:project_id/publish');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/account/projects/:project_id/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/publish';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/publish"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/publish" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/publish",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects/:project_id/publish');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/publish');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/publish' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/publish' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/projects/:project_id/publish")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/publish"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/publish"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/publish")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/projects/:project_id/publish') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/publish";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects/:project_id/publish

http POST {{baseUrl}}/account/projects/:project_id/publish

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/publish

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/publish")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "message": "Project 1 has been published"
}

POST Private Projects search

{{baseUrl}}/account/projects/search

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/search");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/account/projects/search")

require "http/client"

url = "{{baseUrl}}/account/projects/search"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/account/projects/search"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/search");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/search"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/account/projects/search HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/projects/search")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/search"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/search")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/account/projects/search")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/account/projects/search');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/account/projects/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/search';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/search',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/search")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/search',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/account/projects/search'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/account/projects/search');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/account/projects/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/search';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/search" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/account/projects/search');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/search');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/search');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/search' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/search' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/account/projects/search")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/search"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/search"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/account/projects/search') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/search";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/account/projects/search

http POST {{baseUrl}}/account/projects/search

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/account/projects/search

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()

GET Private Projects

{{baseUrl}}/account/projects

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects")

require "http/client"

url = "{{baseUrl}}/account/projects"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/projects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/projects'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/projects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects

http GET {{baseUrl}}/account/projects

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "role": "Owner",
    "storage": "individual"
  }
]

GET Project article details

{{baseUrl}}/account/projects/:project_id/articles/:article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/articles/:article_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/articles/:article_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/articles/:article_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/articles/:article_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/articles/:article_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/articles/:article_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/articles/:article_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/articles/:article_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/articles/:article_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/articles/:article_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/articles/:article_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/articles/:article_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/articles/:article_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/articles/:article_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/articles/:article_id

http GET {{baseUrl}}/account/projects/:project_id/articles/:article_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/articles/:article_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/articles/:article_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "citation": "lilliput, figshare admin (2017): first project item. figshare.\n \n Retrieved: 14 01, May 22, 2017 (GMT)",
  "confidential_reason": "none",
  "created_date": "2017-05-18T11:49:03Z",
  "description": "article description",
  "embargo_date": "2017-05-18T11:49:03Z",
  "embargo_reason": "not complete",
  "embargo_title": "File(s) under embargo",
  "embargo_type": "article",
  "funding": "none",
  "has_linked_file": true,
  "is_active": true,
  "is_confidential": true,
  "is_embargoed": true,
  "is_metadata_record": false,
  "is_public": true,
  "license": {
    "name": "CC BY",
    "url": "http://creativecommons.org/licenses/by/4.0/",
    "value": 1
  },
  "metadata_reason": "hosted somewhere else",
  "modified_date": "2017-05-18T11:49:03Z",
  "references": [
    "http://figshare.com",
    "http://figshare.com/api"
  ],
  "size": 69939,
  "status": "public",
  "tags": [
    "t1",
    "t2",
    "t3"
  ],
  "version": 1
}

GET Project article file details

{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id

QUERY PARAMS

project_id

article_id

file_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/articles/:article_id/files/:file_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/articles/:article_id/files/:file_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/articles/:article_id/files/:file_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/articles/:article_id/files/:file_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id

http GET {{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files/:file_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "is_attached_to_public_version": true,
  "preview_state": "preview not available",
  "status": "created",
  "upload_token": "9dfc5fe3-d617-4d93-ac11-8afe7e984a4b",
  "upload_url": "https://uploads.figshare.com"
}

GET Project article list files

{{baseUrl}}/account/projects/:project_id/articles/:article_id/files

QUERY PARAMS

project_id

article_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/articles/:article_id/files HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/articles/:article_id/files',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id/files');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/articles/:article_id/files');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/articles/:article_id/files' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/articles/:article_id/files")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/articles/:article_id/files') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/articles/:article_id/files

http GET {{baseUrl}}/account/projects/:project_id/articles/:article_id/files

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/articles/:article_id/files

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/articles/:article_id/files")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "is_attached_to_public_version": true,
    "preview_state": "preview not available",
    "status": "created",
    "upload_token": "9dfc5fe3-d617-4d93-ac11-8afe7e984a4b",
    "upload_url": "https://uploads.figshare.com"
  }
]

GET Project note details

{{baseUrl}}/account/projects/:project_id/notes/:note_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/notes/:note_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id/notes/:note_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/notes/:note_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/notes/:note_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id/notes/:note_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/notes/:note_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/notes/:note_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/notes/:note_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/notes/:note_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/notes/:note_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/notes/:note_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/notes/:note_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/notes/:note_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/notes/:note_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/notes/:note_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/notes/:note_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id/notes/:note_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/notes/:note_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id/notes/:note_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id/notes/:note_id

http GET {{baseUrl}}/account/projects/:project_id/notes/:note_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/notes/:note_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/notes/:note_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "text": "text"
}

GET Public Project Articles

{{baseUrl}}/projects/:project_id/articles

QUERY PARAMS

project_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:project_id/articles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/projects/:project_id/articles")

require "http/client"

url = "{{baseUrl}}/projects/:project_id/articles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/projects/:project_id/articles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/:project_id/articles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/projects/:project_id/articles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/projects/:project_id/articles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/projects/:project_id/articles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:project_id/articles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/projects/:project_id/articles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:project_id/articles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/projects/:project_id/articles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:project_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/projects/:project_id/articles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/:project_id/articles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:project_id/articles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/projects/:project_id/articles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:project_id/articles'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:project_id/articles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:project_id/articles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/projects/:project_id/articles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/projects/:project_id/articles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/projects/:project_id/articles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/projects/:project_id/articles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/projects/:project_id/articles');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:project_id/articles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/projects/:project_id/articles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:project_id/articles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:project_id/articles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/projects/:project_id/articles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/projects/:project_id/articles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:project_id/articles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:project_id/articles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/projects/:project_id/articles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/projects/:project_id/articles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/projects/:project_id/articles

http GET {{baseUrl}}/projects/:project_id/articles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:project_id/articles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/:project_id/articles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Public Project

{{baseUrl}}/projects/:project_id

QUERY PARAMS

project_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:project_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/projects/:project_id")

require "http/client"

url = "{{baseUrl}}/projects/:project_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/projects/:project_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/:project_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/projects/:project_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/projects/:project_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/projects/:project_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:project_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/projects/:project_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:project_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/projects/:project_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/projects/:project_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/projects/:project_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/:project_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:project_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/projects/:project_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/projects/:project_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:project_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/projects/:project_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/projects/:project_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/projects/:project_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/projects/:project_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/projects/:project_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/projects/:project_id');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:project_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/projects/:project_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:project_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:project_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/projects/:project_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/projects/:project_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:project_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:project_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/projects/:project_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/projects/:project_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/projects/:project_id

http GET {{baseUrl}}/projects/:project_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:project_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/:project_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

POST Public Projects Search

{{baseUrl}}/projects/search

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/search");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/projects/search")

require "http/client"

url = "{{baseUrl}}/projects/search"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/projects/search"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/search");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/projects/search"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/projects/search HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/projects/search")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/search"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/projects/search")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/projects/search")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/projects/search');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/projects/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/projects/search';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/search',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/search")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/projects/search',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/projects/search'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/projects/search');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/projects/search'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/projects/search';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/projects/search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/projects/search" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/projects/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/projects/search');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/search');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/projects/search');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/search' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/search' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/projects/search")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/projects/search"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/search"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/projects/search') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/projects/search";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/projects/search

http POST {{baseUrl}}/projects/search

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/projects/search

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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()

GET Public Projects

{{baseUrl}}/projects

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/projects")

require "http/client"

url = "{{baseUrl}}/projects"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/projects"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/projects"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/projects HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/projects")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/projects")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/projects")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/projects');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/projects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/projects';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/projects',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/projects'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/projects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/projects';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/projects"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/projects" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/projects",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/projects');

echo $response->getBody();

setUrl('{{baseUrl}}/projects');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/projects');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/projects")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/projects"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/projects') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/projects";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/projects

http GET {{baseUrl}}/projects

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

DELETE Remove project collaborator

{{baseUrl}}/account/projects/:project_id/collaborators/:user_id

QUERY PARAMS

project_id

user_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/account/projects/:project_id/collaborators/:user_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/collaborators/:user_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/collaborators/:user_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id/collaborators/:user_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/collaborators/:user_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/account/projects/:project_id/collaborators/:user_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/account/projects/:project_id/collaborators/:user_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/account/projects/:project_id/collaborators/:user_id

http DELETE {{baseUrl}}/account/projects/:project_id/collaborators/:user_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/collaborators/:user_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/collaborators/:user_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

PUT Update project note

{{baseUrl}}/account/projects/:project_id/notes/:note_id

BODY json

{
  "text": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id/notes/:note_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"text\": \"note to remember\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/projects/:project_id/notes/:note_id" {:content-type :json
                                                                                       :form-params {:text "note to remember"}})

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"text\": \"note to remember\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id/notes/:note_id"),
    Content = new StringContent("{\n  \"text\": \"note to remember\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id/notes/:note_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"text\": \"note to remember\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

	payload := strings.NewReader("{\n  \"text\": \"note to remember\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/account/projects/:project_id/notes/:note_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "text": "note to remember"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"text\": \"note to remember\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id/notes/:note_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"text\": \"note to remember\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"text\": \"note to remember\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .header("content-type", "application/json")
  .body("{\n  \"text\": \"note to remember\"\n}")
  .asString();

const data = JSON.stringify({
  text: 'note to remember'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id',
  headers: {'content-type': 'application/json'},
  data: {text: 'note to remember'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id/notes/:note_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"text":"note to remember"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "text": "note to remember"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"text\": \"note to remember\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id/notes/:note_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id/notes/:note_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({text: 'note to remember'}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id',
  headers: {'content-type': 'application/json'},
  body: {text: 'note to remember'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/projects/:project_id/notes/:note_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  text: 'note to remember'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/projects/:project_id/notes/:note_id',
  headers: {'content-type': 'application/json'},
  data: {text: 'note to remember'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id/notes/:note_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"text":"note to remember"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"text": @"note to remember" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id/notes/:note_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id/notes/:note_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"text\": \"note to remember\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id/notes/:note_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'text' => 'note to remember'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/projects/:project_id/notes/:note_id', [
  'body' => '{
  "text": "note to remember"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id/notes/:note_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'text' => 'note to remember'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'text' => 'note to remember'
]));
$request->setRequestUrl('{{baseUrl}}/account/projects/:project_id/notes/:note_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id/notes/:note_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "text": "note to remember"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id/notes/:note_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "text": "note to remember"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"text\": \"note to remember\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/projects/:project_id/notes/:note_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

payload = { "text": "note to remember" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id/notes/:note_id"

payload <- "{\n  \"text\": \"note to remember\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id/notes/:note_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"text\": \"note to remember\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/projects/:project_id/notes/:note_id') do |req|
  req.body = "{\n  \"text\": \"note to remember\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id/notes/:note_id";

    let payload = json!({"text": "note to remember"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/projects/:project_id/notes/:note_id \
  --header 'content-type: application/json' \
  --data '{
  "text": "note to remember"
}'

echo '{
  "text": "note to remember"
}' |  \
  http PUT {{baseUrl}}/account/projects/:project_id/notes/:note_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "text": "note to remember"\n}' \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id/notes/:note_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["text": "note to remember"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id/notes/:note_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

PUT Update project

{{baseUrl}}/account/projects/:project_id

BODY json

{
  "custom_fields": {},
  "custom_fields_list": [
    {
      "name": "",
      "value": ""
    }
  ],
  "description": "",
  "funding": "",
  "funding_list": [
    {
      "id": 0,
      "title": ""
    }
  ],
  "title": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account/projects/:project_id" {:content-type :json
                                                                        :form-params {:custom_fields {:defined_key "value for it"}
                                                                                      :description "project description"
                                                                                      :funding ""
                                                                                      :title "project title"}})

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id"),
    Content = new StringContent("{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id"

	payload := strings.NewReader("{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/account/projects/:project_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 147

{
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "project description",
  "funding": "",
  "title": "project title"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account/projects/:project_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account/projects/:project_id")
  .header("content-type", "application/json")
  .body("{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}")
  .asString();

const data = JSON.stringify({
  custom_fields: {
    defined_key: 'value for it'
  },
  description: 'project description',
  funding: '',
  title: 'project title'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account/projects/:project_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/projects/:project_id',
  headers: {'content-type': 'application/json'},
  data: {
    custom_fields: {defined_key: 'value for it'},
    description: 'project description',
    funding: '',
    title: 'project title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"custom_fields":{"defined_key":"value for it"},"description":"project description","funding":"","title":"project title"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "description": "project description",\n  "funding": "",\n  "title": "project title"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  custom_fields: {defined_key: 'value for it'},
  description: 'project description',
  funding: '',
  title: 'project title'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/projects/:project_id',
  headers: {'content-type': 'application/json'},
  body: {
    custom_fields: {defined_key: 'value for it'},
    description: 'project description',
    funding: '',
    title: 'project title'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/account/projects/:project_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  custom_fields: {
    defined_key: 'value for it'
  },
  description: 'project description',
  funding: '',
  title: 'project title'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account/projects/:project_id',
  headers: {'content-type': 'application/json'},
  data: {
    custom_fields: {defined_key: 'value for it'},
    description: 'project description',
    funding: '',
    title: 'project title'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"custom_fields":{"defined_key":"value for it"},"description":"project description","funding":"","title":"project title"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"custom_fields": @{ @"defined_key": @"value for it" },
                              @"description": @"project description",
                              @"funding": @"",
                              @"title": @"project title" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'custom_fields' => [
        'defined_key' => 'value for it'
    ],
    'description' => 'project description',
    'funding' => '',
    'title' => 'project title'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/account/projects/:project_id', [
  'body' => '{
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "project description",
  "funding": "",
  "title": "project title"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'description' => 'project description',
  'funding' => '',
  'title' => 'project title'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'custom_fields' => [
    'defined_key' => 'value for it'
  ],
  'description' => 'project description',
  'funding' => '',
  'title' => 'project title'
]));
$request->setRequestUrl('{{baseUrl}}/account/projects/:project_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "project description",
  "funding": "",
  "title": "project title"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "project description",
  "funding": "",
  "title": "project title"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account/projects/:project_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id"

payload = {
    "custom_fields": { "defined_key": "value for it" },
    "description": "project description",
    "funding": "",
    "title": "project title"
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id"

payload <- "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/account/projects/:project_id') do |req|
  req.body = "{\n  \"custom_fields\": {\n    \"defined_key\": \"value for it\"\n  },\n  \"description\": \"project description\",\n  \"funding\": \"\",\n  \"title\": \"project title\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id";

    let payload = json!({
        "custom_fields": json!({"defined_key": "value for it"}),
        "description": "project description",
        "funding": "",
        "title": "project title"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account/projects/:project_id \
  --header 'content-type: application/json' \
  --data '{
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "project description",
  "funding": "",
  "title": "project title"
}'

echo '{
  "custom_fields": {
    "defined_key": "value for it"
  },
  "description": "project description",
  "funding": "",
  "title": "project title"
}' |  \
  http PUT {{baseUrl}}/account/projects/:project_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "custom_fields": {\n    "defined_key": "value for it"\n  },\n  "description": "project description",\n  "funding": "",\n  "title": "project title"\n}' \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "custom_fields": ["defined_key": "value for it"],
  "description": "project description",
  "funding": "",
  "title": "project title"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

GET View project details

{{baseUrl}}/account/projects/:project_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/projects/:project_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account/projects/:project_id")

require "http/client"

url = "{{baseUrl}}/account/projects/:project_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account/projects/:project_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account/projects/:project_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account/projects/:project_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/account/projects/:project_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account/projects/:project_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account/projects/:project_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account/projects/:project_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/account/projects/:project_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account/projects/:project_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account/projects/:project_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account/projects/:project_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account/projects/:project_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account/projects/:project_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/account/projects/:project_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account/projects/:project_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/account/projects/:project_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account/projects/:project_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/projects/:project_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account/projects/:project_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account/projects/:project_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/account/projects/:project_id');

echo $response->getBody();

setUrl('{{baseUrl}}/account/projects/:project_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account/projects/:project_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/projects/:project_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/projects/:project_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account/projects/:project_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account/projects/:project_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account/projects/:project_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account/projects/:project_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/account/projects/:project_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account/projects/:project_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account/projects/:project_id

http GET {{baseUrl}}/account/projects/:project_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account/projects/:project_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/projects/:project_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "account_id": 1000001,
  "created_date": "2017-05-16T14:52:54Z",
  "description": "description",
  "figshare_url": "https://figshare.com/projects/project/1",
  "funding": "none",
  "group_id": 0,
  "modified_date": "2017-05-16T14:52:54Z",
  "quota": 0,
  "used_quota": 0,
  "used_quota_private": 0,
  "used_quota_public": 0
}