Extract the key words and phrases from a text

Extracts the most relevant keywords and key phrases, best first, each with a relevance from 0 to 1 (higher is more relevant).

Request

POSThttps://text-analysis.p.apihiver.com/v1/keywords

Media Type

JSON object. Required: text.

Request Body

Edit the values below to test different scenarios.

{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}

Parameters and body structure are inherited from this endpoint's definition. Changes here only apply to this test run.

Language

Client

1curl --request POST \
2  --url https://text-analysis.p.apihiver.com/v1/keywords \
3  --header 'Accept: application/json' \
4  --header 'Content-Type: application/json' \
5  --header 'X-API-Key: YOUR_API_KEY' \
6  --data '{
7  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
8}'

Extracts the most relevant keywords and key phrases, best first, each with a `relevance` from 0 to 1 (higher is more relevant). This endpoint is part of the Text Analysis API: Sentiment, keywords, extractive summaries, readability scores and text statistics for English text — one simple JSON call each.

Extract the key words and phrases from a text: example requests in every language

POST /v1/keywords in Shell (cURL)

curl --request POST \
  --url https://text-analysis.p.apihiver.com/v1/keywords \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header 'X-API-Key: YOUR_API_KEY' \
  --data '{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}'

POST /v1/keywords in Shell (HTTPie)

echo '{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}' |  \
  http POST https://text-analysis.p.apihiver.com/v1/keywords \
  Accept:application/json \
  Content-Type:application/json \
  X-API-Key:YOUR_API_KEY

POST /v1/keywords in Shell (Wget)

wget --quiet \
  --method POST \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --header 'X-API-Key: YOUR_API_KEY' \
  --body-data '{\n  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."\n}' \
  --output-document \
  - https://text-analysis.p.apihiver.com/v1/keywords

POST /v1/keywords in Node.js (http)

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'text-analysis.p.apihiver.com',
  port: null,
  path: '/v1/keywords',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  }
};

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: 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
}));
req.end();

POST /v1/keywords in Node.js (Request)

const request = require('request');

const options = {
  method: 'POST',
  url: 'https://text-analysis.p.apihiver.com/v1/keywords',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  body: {
    text: 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
  },
  json: true
};

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

  console.log(body);
});

POST /v1/keywords in Node.js (Unirest)

const unirest = require('unirest');

const req = unirest('POST', 'https://text-analysis.p.apihiver.com/v1/keywords');

req.headers({
  'Content-Type': 'application/json',
  Accept: 'application/json',
  'X-API-Key': 'YOUR_API_KEY'
});

req.type('json');
req.send({
  text: 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
});

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

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

POST /v1/keywords in Node.js (Axios)

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

const options = {
  method: 'POST',
  url: 'https://text-analysis.p.apihiver.com/v1/keywords',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  data: {
    text: 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
  }
};

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

POST /v1/keywords in Node.js (Fetch)

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

const url = 'https://text-analysis.p.apihiver.com/v1/keywords';
const options = {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  body: '{"text":"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."}'
};

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

POST /v1/keywords in JavaScript (XMLHttpRequest)

const data = JSON.stringify({
  text: 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
});

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

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

xhr.open('POST', 'https://text-analysis.p.apihiver.com/v1/keywords');
xhr.setRequestHeader('Content-Type', 'application/json');
xhr.setRequestHeader('Accept', 'application/json');
xhr.setRequestHeader('X-API-Key', 'YOUR_API_KEY');

xhr.send(data);

POST /v1/keywords in JavaScript (Axios)

import axios from 'axios';

const options = {
  method: 'POST',
  url: 'https://text-analysis.p.apihiver.com/v1/keywords',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  data: {
    text: 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
  }
};

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

POST /v1/keywords in JavaScript (Fetch)

const url = 'https://text-analysis.p.apihiver.com/v1/keywords';
const options = {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  body: '{"text":"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."}'
};

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

POST /v1/keywords in JavaScript (jQuery)

const settings = {
  async: true,
  crossDomain: true,
  url: 'https://text-analysis.p.apihiver.com/v1/keywords',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  processData: false,
  data: '{\n  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."\n}'
};

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

POST /v1/keywords in Python (http.client)

import http.client

conn = http.client.HTTPSConnection("text-analysis.p.apihiver.com")

payload = "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}"

headers = {
    'Content-Type': "application/json",
    'Accept': "application/json",
    'X-API-Key': "YOUR_API_KEY"
}

conn.request("POST", "/v1/keywords", payload, headers)

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

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

POST /v1/keywords in Python (Requests)

import requests

url = "https://text-analysis.p.apihiver.com/v1/keywords"

payload = { "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is." }
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "X-API-Key": "YOUR_API_KEY"
}

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

print(response.json())

POST /v1/keywords in PHP (cURL)

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://text-analysis.p.apihiver.com/v1/keywords",
  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' => 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
  ]),
  CURLOPT_HTTPHEADER => [
    "Accept: application/json",
    "Content-Type: application/json",
    "X-API-Key: YOUR_API_KEY"
  ],
]);

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

curl_close($curl);

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

POST /v1/keywords in PHP (Guzzle)

<?php

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://text-analysis.p.apihiver.com/v1/keywords', [
  'body' => '{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}',
  'headers' => [
    'Accept' => 'application/json',
    'Content-Type' => 'application/json',
    'X-API-Key' => 'YOUR_API_KEY',
  ],
]);

echo $response->getBody();

POST /v1/keywords in PHP (PECL HTTP v1)

<?php

$request = new HttpRequest();
$request->setUrl('https://text-analysis.p.apihiver.com/v1/keywords');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-Key' => 'YOUR_API_KEY'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'text' => 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
]));

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

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

POST /v1/keywords in PHP (PECL HTTP v2)

<?php

$client = new http\Client;
$request = new http\Client\Request;

$body = new http\Message\Body;
$body->append(json_encode([
  'text' => 'APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.'
]));
$request->setRequestUrl('https://text-analysis.p.apihiver.com/v1/keywords');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-Key' => 'YOUR_API_KEY'
]);

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

echo $response->getBody();

POST /v1/keywords in Java (AsyncHttp)

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "https://text-analysis.p.apihiver.com/v1/keywords")
  .setHeader("Content-Type", "application/json")
  .setHeader("Accept", "application/json")
  .setHeader("X-API-Key", "YOUR_API_KEY")
  .setBody("{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

POST /v1/keywords in Java (java.net.http)

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://text-analysis.p.apihiver.com/v1/keywords"))
    .header("Content-Type", "application/json")
    .header("Accept", "application/json")
    .header("X-API-Key", "YOUR_API_KEY")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}"))
    .build();
HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

POST /v1/keywords in Java (OkHttp)

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}");
Request request = new Request.Builder()
  .url("https://text-analysis.p.apihiver.com/v1/keywords")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("X-API-Key", "YOUR_API_KEY")
  .build();

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

POST /v1/keywords in Java (Unirest)

HttpResponse<String> response = Unirest.post("https://text-analysis.p.apihiver.com/v1/keywords")
  .header("Content-Type", "application/json")
  .header("Accept", "application/json")
  .header("X-API-Key", "YOUR_API_KEY")
  .body("{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}")
  .asString();

POST /v1/keywords in C# (HttpClient)

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("https://text-analysis.p.apihiver.com/v1/keywords"),
    Headers =
    {
        { "Accept", "application/json" },
        { "X-API-Key", "YOUR_API_KEY" },
    },
    Content = new StringContent("{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\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);
}

POST /v1/keywords in C# (RestSharp)

var client = new RestClient("https://text-analysis.p.apihiver.com/v1/keywords");
var request = new RestRequest("", Method.Post);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("X-API-Key", "YOUR_API_KEY");
request.AddParameter("application/json", "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

POST /v1/keywords in Go (NewRequest)

package main

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

func main() {

	url := "https://text-analysis.p.apihiver.com/v1/keywords"

	payload := strings.NewReader("{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}")

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

	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Accept", "application/json")
	req.Header.Add("X-API-Key", "YOUR_API_KEY")

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

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

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

}

POST /v1/keywords in Ruby (net::http)

require 'uri'
require 'net/http'

url = URI("https://text-analysis.p.apihiver.com/v1/keywords")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request["X-API-Key"] = 'YOUR_API_KEY'
request.body = "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}"

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

POST /v1/keywords in Swift (NSURLSession)

import Foundation

let headers = [
  "Content-Type": "application/json",
  "Accept": "application/json",
  "X-API-Key": "YOUR_API_KEY"
]
let parameters = ["text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://text-analysis.p.apihiver.com/v1/keywords")! 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 /v1/keywords in Objective-C (NSURLSession)

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"Content-Type": @"application/json",
                           @"Accept": @"application/json",
                           @"X-API-Key": @"YOUR_API_KEY" };
NSDictionary *parameters = @{ @"text": @"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is." };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://text-analysis.p.apihiver.com/v1/keywords"]
                                                       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];

POST /v1/keywords in Kotlin (OkHttp)

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}")
val request = Request.Builder()
  .url("https://text-analysis.p.apihiver.com/v1/keywords")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Accept", "application/json")
  .addHeader("X-API-Key", "YOUR_API_KEY")
  .build()

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

POST /v1/keywords in C (libcurl)

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "https://text-analysis.p.apihiver.com/v1/keywords");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Content-Type: application/json");
headers = curl_slist_append(headers, "Accept: application/json");
headers = curl_slist_append(headers, "X-API-Key: YOUR_API_KEY");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}");

CURLcode ret = curl_easy_perform(hnd);

POST /v1/keywords in Clojure (clj-http)

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

(client/post "https://text-analysis.p.apihiver.com/v1/keywords" {:headers {:X-API-Key "YOUR_API_KEY"}
                                                                 :content-type :json
                                                                 :form-params {:text "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."}
                                                                 :accept :json})

POST /v1/keywords in OCaml (CoHTTP)

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "https://text-analysis.p.apihiver.com/v1/keywords" in
let headers = Header.add_list (Header.init ()) [
  ("Content-Type", "application/json");
  ("Accept", "application/json");
  ("X-API-Key", "YOUR_API_KEY");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}" in

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

POST /v1/keywords in R (httr)

library(httr)

url <- "https://text-analysis.p.apihiver.com/v1/keywords"

payload <- "{\n  \"text\": \"APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is.\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('X-API-Key' = 'YOUR_API_KEY'), content_type("application/json"), accept("application/json"), encode = encode)

content(response, "text")

POST /v1/keywords in PowerShell (Invoke-WebRequest)

$headers=@{}
$headers.Add("Content-Type", "application/json")
$headers.Add("Accept", "application/json")
$headers.Add("X-API-Key", "YOUR_API_KEY")
$response = Invoke-WebRequest -Uri 'https://text-analysis.p.apihiver.com/v1/keywords' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}'

POST /v1/keywords in PowerShell (Invoke-RestMethod)

$headers=@{}
$headers.Add("Content-Type", "application/json")
$headers.Add("Accept", "application/json")
$headers.Add("X-API-Key", "YOUR_API_KEY")
$response = Invoke-RestMethod -Uri 'https://text-analysis.p.apihiver.com/v1/keywords' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}'

POST /v1/keywords in HTTP (HTTP/1.1)

POST /v1/keywords HTTP/1.1
Content-Type: application/json
Accept: application/json
X-Api-Key: YOUR_API_KEY
Host: text-analysis.p.apihiver.com
Content-Length: 303

{
  "text": "APIHiver is a marketplace where developers discover, test and subscribe to APIs. Providers publish their APIs with documentation and pricing plans. The platform handles keys, billing and analytics so that developers can focus on building great products. Many teams love how simple it is."
}

Example response (200, application/json)

Success.

1{
2  "keywords": [
3    {
4      "keyword": "test and subscribe",
5      "relevance": 1
6    },
7    {
8      "keyword": "developers discover",
9      "relevance": 0.4243
10    },
11    {
12      "keyword": "APIHiver",
13      "relevance": 0.2161
14    }
15  ]
16}

Errors

400 — A required parameter is missing or a value has the wrong format.

1{
2  "error": {
3    "code": "INVALID_INPUT",
4    "message": "text: Field required"
5  }
6}

Gateway errors (missing key, no subscription, rate limits) are listed in Error codes.

Other Text Analysis API endpoints

Text Analysis API pricing →·Text Analysis API overview →