Text Readability Metrics API

curl --location --request POST 'https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.' --header 'Authorization: Bearer YOUR_API_KEY' 


    

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();

        // Build the GET request
        Request request = new Request.Builder()
            .url("https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.")
            .get() // Use GET method without a body
            .addHeader("Authorization", "Bearer YOUR_API_KEY")
            .build();

        // Execute the request
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                // Handle the response in case of a successful request
                String responseData = response.body().string();
                System.out.println(responseData);
            } else {
                // Handle errors
                System.out.println("Request error: " + response.code());
            }
        } catch (IOException e) {
            // Handle I/O exceptions
            e.printStackTrace();
        }
    }
}

var settings = {
  "url": "https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY"
  },
};

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

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
    
xhr.addEventListener("readystatechange", function() {
if(this.readyState === 4) {
    console.log(this.responseText);
    }
});
    
xhr.open("POST", "https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.");
xhr.setRequestHeader("Authorization", "Bearer YOUR_API_KEY");

var axios = require('axios');
var config = {
method: 'POST',
url: 'https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.',
headers: { 
    'Authorization': 'Bearer YOUR_API_KEY'
    },
};
axios(config).then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});

$curl = curl_init();
    
curl_setopt_array($curl, array(
CURLOPT_URL => 'https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_HTTPHEADER => array(
    'Authorization: Bearer YOUR_API_KEY'
    ),
));
    
$response = curl_exec($curl);
    
curl_close($curl);
echo $response;

import requests
    
url = "https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense."
    
headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}
    
response = requests.request("POST", url, headers=headers, data=payload)
    
print(response.text)
    

require "uri"
require "net/http"
    
url = URI("https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.")
    
http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::POST.new(url)
request["Authorization"] = "Bearer YOUR_API_KEY"
    
response = http.request(request)
puts response.read_body

http --follow --timeout 3600 POST 'https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.' \
Authorization:'Bearer YOUR_API_KEY'

var client = new RestClient("https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense.");
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer YOUR_API_KEY");
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);

package main
import (
    "fmt"
    "net/http"
    "io/ioutil"
)
func main() {
    url := "https://zylalabs.com/api/1820/text+readability+metrics+api/1481/get+metrics?text=The word logorrhoea is often used pejoratively  to describe prose that is highly abstract and  contains little concrete language. Since abstract  writing is hard to visualize, it often seems as though  it makes no sense and all the words are excessive.  Writers in academic fields that concern themselves mostly  with the abstract, such as philosophy and especially  postmodernism, often fail to include extensive concrete  examples of their ideas, and so a superficial examination  of their work might lead one to believe that it is all nonsense."
    method := "POST"
    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)
    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}