An API for analyzing textual data with semantic and topic recognition.

v2.0:

• New version of the text analysis API
  • Moved project under Spring Boot framework
  • Only accepting JSON request objects in the body of the message
  • Better character handling
  • Improved error handling
  • Added functionality for exclude and filter handling

Neticle Text Analysis provides market leading, humanly accurate sentiment and semantic analysis.

• Entity oriented sentiment analysis: in a text only the phrases, entities and labels related to the set target entity are analyzed. The target is set by it's synonyms, spelling and misspellings.

• Document level sentiment analysis: in a text every phrases, entities and labels are analyzed. In this case no synonyms are given as input parameter.

• Attribute recognition: service and product attributes (for example: screen, bandwidth, etc.) are recognized.

• Topic recognition: key topics (for example: 3G, mobile payment, etc.) are recognized.

• Location recognition: related locations (for example: Hungary, Pécs, etc.) are recognized.

• Brand recognition: related brands (for example: Audi, Mercedes, etc.) are recognized.

• Emotion recognition: related emotions (for example: joy, etc.) are recognized.

• Person recognition: related persons (for example: Bill Gates, etc.) are recognized.

• Organization recognition: related organizations (for example: UNICEF, etc.) are recognized.

• Event recognition: related events (for example: festivals, conferences, etc.) are recognized.

• Business topic recognition: related business topics (for example: revenue, IPO, etc.) are recognized.

• Legal topic recognition: related legal topics (for example: lawsuit, legislation, etc.) are recognized.

• Medical topic recognition: related medical topics (for example: receipt, symptom, etc.) are recognized.

• HR topic recognition: related HR topics (for example: job, salary, etc.) are recognized.

https://textanalysis.neticle.com/2.0/text_analysis

{
  "language": "en",
  "token": "token_from_neticle",
  "input": "I like this neighborhood, but the 4g net is terrible here.",
  "callid": "internal system 1",
  "format": "json",
  "stem": false,
  "replaceaccent": false,
  "lowercase": false,
  "keywords": [
    {
      "id": "net_keyword_1",
      "synonyms": ["net","Net","NET"],
      "excludes": ["fish","Fish","FISH"],
      "filters": ["3g","3G","4g","4G"]
    }
  ]
}

{
    "results": [
        {
            "analyzed": true,
            "keyword": "net_keyword_1",
            "processing_time_in_ms": 325,
            "html_formatted_text": "I like this neighborhood, <span class=\"contain_keyword\">but the 4g <span class=\"synonym\">net</span> <span class=\"phrase_neg_lvl2 polarity_item\" title=\"-2 \">is terrible</span> here</span>.",
            "recognized_negative_phrases": [
                {
                    "mentions": [
                        " but the 4g net is terrible here"
                    ],
                    "related_pos_phrases": [],
                    "related_neg_phrases": [],
                    "related_entities": [
                        {
                            "entity_name": "4g",
                            "entity_type": "topic",
                            "related_mention_number": 1,
                            "mentions": [
                                " but the 4g net is terrible here"
                            ]
                        }
                    ],
                    "mention_number": 1,
                    "entity_opinion_index": -2.0,
                    "phrase": "is terrible"
                }
            ],
            "recognized_positive_phrases": [],
            "entities": [
                {
                    "mentions": [
                        " but the 4g net is terrible here"
                    ],
                    "related_pos_phrases": [],
                    "related_neg_phrases": [],
                    "related_entities": [
                        {
                            "entity_name": "is terrible",
                            "entity_type": "neg_phrase",
                            "related_mention_number": 1,
                            "mentions": [
                                " but the 4g net is terrible here"
                            ]
                        }
                    ],
                    "mention_number": 1,
                    "entity_opinion_index": -2.0,
                    "entity_name": "4g",
                    "entity_type": "topic"
                }
            ],
            "recognized_synonyms": [
                "net"
            ],
            "recognized_excludes": [],
            "recognized_filters": [
                "4g"
            ],
            "keyword_stats": {
                "total_keyword_hit_number": 1,
                "total_synonym_hit_numbers": [
                    {
                        "synonym_hit_number": 1,
                        "synonym_hit": "net"
                    }
                ]
            },
            "opinion_index": -2.0,
            "summarized_positive_opinion_index": 0.0,
            "summarized_negative_opinion_index": -2.0
        }
    ],
    "error_code": 0,
    "error_message": "",
    "call_id": "internal system 1",
    "input_length": 58,
    "total_processing_time_in_ms": 325
}

curl --header "Content-Type: application/json" --request POST --data '{"language":"en","token":"token_from_neticle","input":"I like this neighborhood, but the 4g net is terrible here.","callid": "internal system 1","format":"json","stem":false,"replaceaccent":false,"lowercase":false,"keywords":[{"id": "net_keyword_1","synonyms":["net","Net","NET"],"excludes":["fish","Fish","FISH"],"filters":["3g","3G","4g","4G"]}]}' https://textanalysis.neticle.com/2.0/text_analysis

Maven dependencies:

<dependency>
    <groupId>com.mashape.unirest</groupId>
    <artifactId>unirest-java</artifactId>
    <version>1.4.9</version>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

Java code example:

package com.neticle;

import com.google.gson.Gson;
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.JsonNode;
import com.mashape.unirest.http.Unirest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TestApplication {
    
    public static void main(String[] args) {
        TestApplication obj = new TestApplication();
        obj.run();
    }
    
    public void run(){
        try {
            // Creating google json parser.
            Gson gson = new Gson();
            
            TextAnalysisKeyword textAnalysisKeyword = new TextAnalysisKeyword();
            textAnalysisKeyword.setId("net_keyword_1");
            textAnalysisKeyword.setSynonyms(Arrays.asList("net","Net","NET"));
            textAnalysisKeyword.setExcludes(Arrays.asList("fish","Fish","FISH"));
            textAnalysisKeyword.setFilters(Arrays.asList("3g","3G","4g","4G"));
            
            // Creating request object.
            TextAnalysisApiRequest textAnalysisApiRequest = new TextAnalysisApiRequest();
            textAnalysisApiRequest.setCallid("internal system 1");
            textAnalysisApiRequest.setFormat("json");
            textAnalysisApiRequest.setInput("I like this neighborhood, but the 4g net is terrible here.");
            textAnalysisApiRequest.setLanguage("en");
            textAnalysisApiRequest.setLowercase(false);
            textAnalysisApiRequest.setReplaceaccent(false);
            textAnalysisApiRequest.setStem(false);
            textAnalysisApiRequest.setToken("token_from_neticle");
            textAnalysisApiRequest.setKeywords(Arrays.asList(textAnalysisKeyword));
            
            // Sending request object in body as json.
            // Receiving json object as answer.
            HttpResponse<JsonNode> jsonResponse = Unirest.post("https://textanalysis.neticle.com/2.0/text_analysis")
                .header("content-type", "application/json")
                .body(gson.toJson(textAnalysisApiRequest))
                .asJson();
            
            // Printing result.
            System.out.println(jsonResponse.getBody().getObject().toString());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }    
    }
    
    public class TextAnalysisApiRequest {
        private String language = "";
        private String token = "";
        private String input = "";
        private String callid = "";
        private String format = "json";
        private boolean stem = false;
        private boolean replaceaccent = false;
        private boolean lowercase = false;
        private List<TextAnalysisKeyword> keywords = new ArrayList<>();

        public TextAnalysisApiRequest() {}
        public String getLanguage() {return language;}
        public void setLanguage(String language) {this.language = language;}
        public String getToken() {return token;}
        public void setToken(String token) {this.token = token;}
        public String getInput() {return input;}
        public void setInput(String input) {this.input = input;}
        public boolean isStem() {return stem;}
        public void setStem(boolean stem) {this.stem = stem;}
        public boolean isReplaceaccent() {return replaceaccent;}
        public void setReplaceaccent(boolean replaceaccent) {this.replaceaccent = replaceaccent;}
        public String getCallid() {return callid;}
        public void setCallid(String callid) {this.callid = callid;}
        public String getFormat() {return format;}
        public void setFormat(String format) {this.format = format;}
        public boolean isLowercase() {return lowercase;}
        public void setLowercase(boolean lowercase) {this.lowercase = lowercase;}
        public List<TextAnalysisKeyword> getKeywords() {return keywords;}
        public void setKeywords(List<TextAnalysisKeyword> keywords) {this.keywords = keywords;}
    }
    
    public class TextAnalysisKeyword {
        private String id = "";
        private List<String> synonyms = new ArrayList();
        private List<String> excludes = new ArrayList();
        private List<String> filters = new ArrayList();

        public TextAnalysisKeyword() {}
        public String getId() {return id;}
        public void setId(String id) {this.id = id;}
        public List<String> getSynonyms() {return synonyms;}
        public void setSynonyms(List<String> synonyms) {this.synonyms = synonyms;}
        public List<String> getExcludes() {return excludes;}
        public void setExcludes(List<String> excludes) {this.excludes = excludes;}
        public List<String> getFilters() {return filters;}
        public void setFilters(List<String> filters) {this.filters = filters;}
    }
}

Composer dependency:

php composer.phar require guzzlehttp/guzzle:~6.0

<?php
require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();
$httpResponse = $client->post('https://textanalysis.neticle.com/2.0/text_analysis', [
    'json' => [
        'language' => 'en',
        'token' => 'token_from_neticle',
        'input' => 'I like this neighborhood, but the 4g net is terrible here.',
        'callid' => 'internal system 1',
        'format' => 'json',
        'stem' => false,
        'replaceaccent' => false,
        'lowercase' => false,
        'keywords' => [
            'id' => 'net_keyword_1',
            'synonyms' => ['net', 'Net', 'NET'],
            'excludes' => ['fish', 'Fish', 'FISH'],
            'filters' => ['3g', '3G', '4g', '4G'],
        ],
    ],
]);

var_dump(json_decode($httpResponse->getBody()->getContents()));

import requests

url = 'https://textanalysis.neticle.com/2.0/text_analysis'
body = {
  'language': 'en',
  'token': 'zurvey3435xsd',
  'input': 'I like this neighborhood, but the 4g net is terrible here.',
  'callid': 'internal system 1',
  'format': 'json',
  'stem': False,
  'replaceaccent': False,
  'lowercase': False,
  'keywords': [
    {
      'id': 'net_keyword_1',
      'synonyms': ['net','Net','NET'],
      'excludes': ['fish','Fish','FISH'],
      'filters': ['3g','3G','4g','4G']
    }
  ]
}
headers = {'Content-type': 'application/json'}

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

print response.json()