<dependency>
  <groupId>com.ibm.watson</groupId>
  <artifactId>ibm-watson</artifactId>
  <version>10.1.0</version>
</dependency>

compile 'com.ibm.watson:ibm-watson:10.1.0'

npm install ibm-watson@^7.1.2

pip install --upgrade "ibm-watson>=6.1.0"

gem install ibm_watson

go get -u github.com/watson-developer-cloud/go-sdk/v2@v3.0.0

pod 'IBMWatsonNaturalLanguageUnderstandingV1', '~> 5.0.0'

github "watson-developer-cloud/swift-sdk" ~> 5.0.0

.package(url: "https://github.com/watson-developer-cloud/swift-sdk", from: "5.0.0")

Install-Package IBM.Watson.NaturalLanguageUnderstanding.v1 -Version 6.1.0

dotnet add package IBM.Watson.NaturalLanguageUnderstanding.v1 --version 6.1.0

<PackageReference Include="IBM.Watson.NaturalLanguageUnderstanding.v1" Version="6.1.0" />

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.ibm.com",
  "features": {
    "categories": {
      "limit": 3
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "www.ibm.com"
  limit := int64(3)

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Categories: &naturallanguageunderstandingv1.CategoriesOptions{
          Limit: &limit,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String url = "www.ibm.com";

CategoriesOptions categories= new CategoriesOptions.Builder()
  .limit(3)
  .build();

Features features = new Features.Builder()
  .categories(categories)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'www.ibm.com',
  'features': {
    'categories': {
      'limit': 3
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, CategoriesOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='www.ibm.com',
    features=Features(categories=CategoriesOptions(limit=3))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "www.ibm.com",
  features: {categories: {limit:3}}
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let categories = CategoriesOptions(limit: 3)
let features = Features(categories: categories)
naturalLanguageUnderstanding.analyze(features: features, url: "www.ibm.com") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    url: "www.ibm.com",
    features: new Features()
    {
        Categories = new CategoriesOptions()
        {
            Limit = 3
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;
NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Categories = new CategoriesOptions()
    {
        Limit = 3
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "www.ibm.com",
    features: features
);

{
    "usage": {
        "text_units": 1,
        "text_characters": 1536,
        "features": 1
    },
    "retrieved_url": "https://www.ibm.com/us-en",
    "language": "en",
    "categories": [
        {
            "score": 0.997152,
            "label": "/technology & computing/computing/internet/cloud computing"
        },
        {
            "score": 0.984064,
            "label": "/technology & computing/computing/computer software and applications"
        },
        {
            "score": 0.962747,
            "label": "/technology & computing/computing/data storage and warehousing"
        }
    ]
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.ibm.com",
  "features": {
    "classifications": {
      "model": "your-model-id"
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "www.ibm.com"
  model := "your-model-id"

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Classifications: &naturallanguageunderstandingv1.ClassificationsOptions{
          Model: &model,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String url = "www.ibm.com";

ClassificationsOptions classifications = new ClassificationsOptions.Builder()
  .model(your-model-id)
  .build();

Features features = new Features.Builder()
  .classifications(classifications)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'www.ibm.com',
  'features': {
    'classifications': {
      'model': 'your-model-id'
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, ClassificationsOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='www.ibm.com',
    features=Features(classifications=ClassificationsOptions(model='your-model-id'))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "www.ibm.com",
  features: {classifications: {model: "your-model-id"}}
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let classifications = ClassificationsOptions(model: "your-model-id")
let features = Features(classifications: classifications)
naturalLanguageUnderstanding.analyze(features: features, url: "www.ibm.com") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    url: "www.ibm.com",
    features: new Features()
    {
        Classifications = new ClassificationsOptions()
        {
            Model = "your-model-id"
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;
NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Classifications = new ClassificationsOptions()
    {
        Model = "your-model-id"
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "www.ibm.com",
    features: features
);

{
    "classifications": [
        {
            "class_name": "temperature",
            "confidence": 0.562519
        },
        {
            "class_name": "conditions",
            "confidence": 0.433996
        },
        {
            "class_name": "satisfied",
            "confidence": 0.355816
        }
    ],
    "language": "en",
    "usage": {
        "features": 0,
        "text_characters": 36,
        "text_units": 1
    }
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.ibm.com",
  "features": {
    "concepts": {
      "limit": 3
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "www.ibm.com"
  limit := int64(3)

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Concepts: &naturallanguageunderstandingv1.ConceptsOptions{
          Limit: &limit,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");


String url = "www.ibm.com";

ConceptsOptions concepts= new ConceptsOptions.Builder()
  .limit(3)
  .build();

Features features = new Features.Builder()
  .concepts(concepts)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'www.ibm.com',
  'features': {
    'concepts': {
      'limit': 3
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, ConceptsOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='www.ibm.com',
    features=Features(concepts=ConceptsOptions(limit=3))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "www.ibm.com",
  features: {concepts: {limit:3}}
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let concepts = ConceptsOptions(limit: 3)
let features = Features(concepts: concepts)
naturalLanguageUnderstanding.analyze(features: features, url: "www.ibm.com") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    url: "www.ibm.com",
    features: new Features()
    {
        Concepts = new ConceptsOptions()
        {
            Limit = 3
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Concepts = new ConceptsOptions()
    {
        Limit = 3
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "www.ibm.com",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 1536,
    "features": 1
  },
  "retrieved_url": "http://www.ibm.com/us-en/",
  "concepts": [
    {
      "text": "Social network service",
      "relevance": 0.92186,
      "dbpedia_resource": "http://dbpedia.org/resource/Social_network_service"
    },
    {
      "text": "Thomas J. Watson",
      "relevance": 0.871908,
      "dbpedia_resource": "http://dbpedia.org/resource/Thomas_J._Watson"
    },
    {
      "text": "Lotus Software",
      "relevance": 0.839578,
      "dbpedia_resource": "http://dbpedia.org/resource/Lotus_Software"
    }
  ],
  "language": "en"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "html": "<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don't like oranges.</p></body></html>",
  "features": {
    "emotion": {
      "targets": [
        "apples",
        "oranges"
      ]
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  html := "<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don't like oranges.</p></body></html>"
  targets := []string{"apples", "oranges"}

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      HTML: &html,
      Features: &naturallanguageunderstandingv1.Features{
        Emotion: &naturallanguageunderstandingv1.EmotionOptions{
          Targets: targets,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String html = "<html><head><title>Fruits</title></head>" +
  "<body><h1>Apples and Oranges</h1>" +
  "<p>I love apples! I don't like oranges.</p>" +
  "</body></html>";

List<String> targets = new ArrayList<>();
targets.add("apples");
targets.add("oranges");

EmotionOptions emotion= new EmotionOptions.Builder()
  .targets(targets)
  .build();

Features features = new Features.Builder()
  .emotion(emotion)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .html(html)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'html': '<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don\'t like oranges.</p></body></html>',
  'features': {
    'emotion': {
      'targets': [
        'apples',
        'oranges'
      ]
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, EmotionOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    html="<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don't like oranges.</p></body></html>",
    features=Features(emotion=EmotionOptions(targets=['apples','oranges']))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  html: "<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don't like oranges.</p></body></html>",
  features: {emotion: {targets: ['apples','oranges']}}
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let html = "<html><head><title>Fruits</title></head>" +
  "<body><h1>Apples and Oranges</h1>" +
  "<p>I love apples! I don't like oranges.</p>" +
  "</body></html>"
let emotion = EmotionOptions(targets: ["apples", "oranges"])
let features = Features(emotion: emotion)
naturalLanguageUnderstanding.analyze(features: features, html: html) {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    html: "<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don't like oranges.</p></body></html>",
    features: new Features()
    {
        Emotion = new EmotionOptions()
        {
            Targets = new List<string> { "apples", "oranges" }
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;
NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Emotion = new EmotionOptions()
    {
        Targets = {"apples","oranges"}
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    html: "<html><head><title>Fruits</title></head><body><h1>Apples and Oranges</h1><p>I love apples! I don't like oranges.</p></body></html>",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 37,
    "features": 1
  },
  "language": "en",
  "emotion": {
    "targets": [
      {
        "text": "apples",
        "emotion": {
          "sadness": 0.028574,
          "joy": 0.859042,
          "fear": 0.02752,
          "disgust": 0.017519,
          "anger": 0.012855
        }
      },
      {
        "text": "oranges",
        "emotion": {
          "sadness": 0.514253,
          "joy": 0.078317,
          "fear": 0.074223,
          "disgust": 0.058103,
          "anger": 0.126859
        }
      }
    ],
    "document": {
      "emotion": {
        "sadness": 0.32665,
        "joy": 0.563273,
        "fear": 0.033387,
        "disgust": 0.022637,
        "anger": 0.041796
      }
    }
  }
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.cnn.com",
  "features": {
    "entities": {
      "sentiment": true,
      "limit": 1
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "www.cnn.com"
  sentiment := true
  limit := int64(1)

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Entities: &naturallanguageunderstandingv1.EntitiesOptions{
          Sentiment: &sentiment,
          Limit: &limit,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String url = "www.cnn.com";

EntitiesOptions entities= new EntitiesOptions.Builder()
  .sentiment(true)
  .limit(1)
  .build();

Features features = new Features.Builder()
  .entities(entities)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'www.cnn.com',
  'features': {
    'entities': {
      'sentiment': true,
      'limit': 1
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, EntitiesOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='www.cnn.com',
    features=Features(entities=EntitiesOptions(sentiment=True,limit=1))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "www.cnn.com",
  features: {entities: {sentiment: true, limit: 1}
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let entities = EntitiesOptions(limit: 1, sentiment: true)
let features = Features(entities: entities)
naturalLanguageUnderstanding.analyze(features: features, url: "www.cnn.com") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    url: "www.cnn.com",
    features: new Features()
    {
        Entities = new EntitiesOptions()
        {
            Sentiment = true,
            Limit = 1
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Entities = new EntitiesOptions()
    {
        Limit = 1,
        Sentiment = true
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "www.cnn.com",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 2708,
    "features": 1
  },
  "retrieved_url": "http://www.cnn.com/",
  "language": "en",
  "entities": [
    {
      "type": "Company",
      "text": "CNN",
      "sentiment": {
        "score": 0.0,
        "label": "neutral"
      },
      "relevance": 0.784947,
      "disambiguation": {
        "subtype": [
          "Broadcast",
          "AwardWinner",
          "RadioNetwork",
          "TVNetwork"
        ],
        "name": "CNN",
        "dbpedia_resource": "http://dbpedia.org/resource/CNN"
      },
      "count": 9
    }
  ]
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.ibm.com",
  "features": {
    "keywords": {
      "sentiment": true,
      "emotion": true,
      "limit": 3
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "www.ibm.com"
  sentiment := true
  emotion := true
  limit := int64(3)

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Keywords: &naturallanguageunderstandingv1.KeywordsOptions{
          Sentiment: &sentiment,
          Emotion: &emotion,
          Limit: &limit,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String url = "www.ibm.com";

KeywordsOptions keywords= new KeywordsOptions.Builder()
  .sentiment(true)
  .emotion(true)
  .limit(3)
  .build();

Features features = new Features.Builder()
  .keywords(keywords)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'www.ibm.com',
  'features': {
    'keywords': {
      'sentiment': true,
      'emotion': true,
      'limit': 3
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, KeywordsOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='www.ibm.com',
    features=Features(keywords=KeywordsOptions(sentiment=True,emotion=True,limit=2))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "www.ibm.com",
  features: {keywords: {sentiment: true, emotion: true, limit: 3}
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let keywords = KeywordsOptions(limit: 3, sentiment: true, emotion: true)
let features = Features(keywords: keywords)
naturalLanguageUnderstanding.analyze(features: features, url: "www.ibm.com") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    url: "www.ibm.com",
    features: new Features()
    {
        Keywords = new KeywordsOptions()
        {
            Sentiment = true,
            Emotion = true,
            Limit = 2
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Keywords = new KeywordsOptions()
    {
        Limit = 3,
        Sentiment = true,
        Emotion = true
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "www.ibm.com",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 1536,
    "features": 1
  },
  "keywords": [
    {
      "text": "curated online courses",
      "sentiment": {
        "score": 0.792454
      },
      "relevance": 0.864624,
      "emotions": {
        "sadness": 0.188625,
        "joy": 0.522781,
        "fear": 0.12012,
        "disgust": 0.103212,
        "anger": 0.106669
      }
    },
    {
      "text": "free virtual server",
      "sentiment": {
        "score": 0.664726
      },
      "relevance": 0.864593,
      "emotions": {
        "sadness": 0.265225,
        "joy": 0.532354,
        "fear": 0.07773,
        "disgust": 0.090112,
        "anger": 0.102242
      }
    }
  ],
  "language": "en",
  "retrieved_url": "https://www.ibm.com/us-en/"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.ibm.com",
  "features": {
    "metadata": {}
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "www.ibm.com"

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Metadata: make(map[string]string{}),
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String url = "www.ibm.com";

Map<String, Object> metadata= new HashMap<String, Object>();

Features features = new Features.Builder()
  .metadata(metadata)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'www.ibm.com',
  'features': {
    'metadata': {}
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='www.ibm.com',
    features=Features(metadata=())).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "www.ibm.com",
  features: {metadata: {}
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let features = Features(metadata: ["": .string("")])
naturalLanguageUnderstanding.analyze(features: features, url: "www.ibm.com") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

Dictionary<string, object> metadata = new Dictionary<string, object>();

var result = naturalLanguageUnderstanding.Analyze(
    url: "www.ibm.com",
    features: new Features()
    {
        Metadata = metadata
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Dictionary<string, object> metadata = new Dictionary<string, object>();

Features features = new Features()
{
    Metadata = metadata
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "www.ibm.com",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 1536,
    "features": 1
  },
  "retrieved_url": "https://www.ibm.com/us-en/",
  "metadata": {
    "title": "IBM - United States",
    "publication_date": "2015-10-01T00:00:00",
    "image": "",
    "feeds": [],
    "authors": []
  },
  "language": "en"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "features": {
    "relations": {}
  },
  "text": "Leonardo DiCaprio won Best Actor in a Leading Role for his performance."
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  text := "Leonardo DiCaprio won Best Actor in a Leading Role for his performance."

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      Text: &text,
      Features: &naturallanguageunderstandingv1.Features{
        Relations: &naturallanguageunderstandingv1.RelationsOptions{},
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String text = "Leonardo DiCaprio won Best Actor" +
  " in a Leading Role for his performance.";

RelationsOptions relations = new RelationsOptions.Builder()
  .build();

Features features = new Features.Builder()
  .relations(relations)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .text(text)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'features': {
    'relations': {}
  },
  'text': 'Leonardo DiCaprio won Best Actor in a Leading Role for his performance.'
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, RelationsOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    text='Leonardo DiCaprio won Best Actor in a Leading Role for his performance.',
    features=Features(relations=RelationsOptions())).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  text: "Leonardo DiCaprio won Best Actor in a Leading Role for his performance.",
  features: {relations: {}
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let text = "Leonardo DiCaprio won Best Actor" +
           " in a Leading Role for his performance."
let features = Features(relations: RelationsOptions())
naturalLanguageUnderstanding.analyze(features: features, text: text) {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    text: "Leonardo DiCaprio won Best Actor in a Leading Role for his performance.",
    features: new Features()
    {
        Relations = new RelationsOptions()
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Relations = new RelationsOptions()
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    text: "Leonardo DiCaprio won Best Actor in a Leading Role for his performance.",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 79,
    "features": 1
  },
  "relations": [
    {
      "type": "awardedTo",
      "sentence": "Leonardo DiCaprio won Best Actor in a Leading Role for his performance.",
      "score": 0.680715,
      "arguments": [
        {
          "text": "Best Actor",
          "location": [
            22,
            32
          ],
          "entities": [
            {
              "type": "EntertainmentAward",
              "text": "Best Actor"
            }
          ]
        },
        {
          "text": "Leonardo DiCaprio",
          "location": [
            0,
            17
          ],
          "entities": [
            {
              "type": "Person",
              "text": "Leonardo DiCaprio"
            }
          ]
        }
      ]
    }
  ],
  "language": "en"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "features": {
    "semantic_roles": {}
  },
  "text": "IBM has one of the largest workforces in the world"
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  text := "IBM has one of the largest workforces in the world"

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      Text: &text,
      Features: &naturallanguageunderstandingv1.Features{
        SemanticRoles: &naturallanguageunderstandingv1.SemanticRolesOptions{},
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String text = "IBM has one of the largest" +
  " workforces in the world";

SemanticRolesOptions semanticRoles = new SemanticRolesOptions.Builder()
  .build();

Features features = new Features.Builder()
  .semanticRoles(semanticRoles)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .text(text)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'features': {
    'semantic_roles': {}
  },
  'text': 'IBM has one of the largest workforces in the world'
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, SemanticRolesOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    text='IBM has one of the largest workforces in the world',
    features=Features(semantic_roles=SemanticRolesOptions())).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  text: "IBM has one of the largest workforces in the world",
  features: {semantic_roles: {}
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let text = "IBM has one of the largest" +
            " workforces in the world"
let semanticRoles = Features(semanticRoles: SemanticRolesOptions())
naturalLanguageUnderstanding.analyze(features: semanticRoles, text: text) {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    text: "IBM has one of the largest workforces in the world",
    features: new Features()
    {
        SemanticRoles = new SemanticRolesOptions()
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    SemanticRoles = new SemanticRolesOptions()
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    text: "IBM has one of the largest workforces in the world",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 50,
    "features": 1
  },
  "semantic_roles": [
    {
      "subject": {
        "text": "IBM"
      },
      "sentence": "IBM has one of the largest workforces in the world",
      "object": {
        "text": "one of the largest workforces in the world"
      },
      "action": {
        "verb": {
          "text": "have",
          "tense": "present"
        },
        "text": "has",
        "normalized": "have"
      }
    }
  ],
  "language": "en"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "https://en.wikipedia.org/wiki/Emmanuel_Macron",
  "features": {
    "sentiment": {
      "targets": [
        "France"
      ]
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  url := "https://en.wikipedia.org/wiki/Emmanuel_Macron"
  targets := []string{"France"}

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      URL: &url,
      Features: &naturallanguageunderstandingv1.Features{
        Sentiment: &naturallanguageunderstandingv1.SentimentOptions{
          Targets: targets,
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String url = "https://en.wikipedia.org/wiki/Emmanuel_Macron";

List<String> targets = new ArrayList<>();
targets.add("France");

SentimentOptions sentiment = new SentimentOptions.Builder()
  .targets(targets)
  .build();

Features features = new Features.Builder()
  .sentiment(sentiment)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .url(url)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'url': 'https://en.wikipedia.org/wiki/Emmanuel_Macron',
  'features': {
    'sentiment': {
      'targets': [
        'France'
      ]
    }
  }
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, SentimentOptions

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    url='https://en.wikipedia.org/wiki/Emmanuel_Macron',
    features=Features(sentiment=SentimentOptions(targets=['France']))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  url: "https://en.wikipedia.org/wiki/Emmanuel_Macron",
  features: {sentiment: {targets=["France"]}
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let sentiment = SentimentOptions(targets: ["France"])
let features = Features(sentiment: sentiment)
naturalLanguageUnderstanding.analyze(features: features, url: "https://en.wikipedia.org/wiki/Emmanuel_Macron") {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    url: "https://en.wikipedia.org/wiki/Emmanuel_Macron",
    features: new Features()
    {
        Sentiment = new SentimentOptions()
        {
            Targets = new List<string>() { "France" }
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Sentiments = new SentimentOptions()
    {
      Targets = {"France"}
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    url: "https://en.wikipedia.org/wiki/Emmanuel_Macron",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 1188,
    "features": 1
  },
  "sentiment": {
    "targets": [
      {
        "text": "France",
        "score": 0.279964,
        "label": "positive"
      }
    ],
    "document": {
      "score": 0.127034,
      "label": "positive"
    }
  },
  "retrieved_url": "https://en.wikipedia.org/wiki/Emmanuel_Macron",
  "language": "en"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "text": "With great power comes great responsibility",
  "features": {
    "syntax": {
      "sentences": true,
      "tokens": {
        "lemma": true,
        "part_of_speech": true
      }
    }
  }
}

package main

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey:     "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "2022-04-07",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")

  text := "With great power comes great responsibility"
  sentences := true
  lemma := true
  partOfSpeech := true

  response, responseErr := naturalLanguageUnderstanding.Analyze(
    &naturallanguageunderstandingv1.AnalyzeOptions{
      Text: &text,
      Features: &naturallanguageunderstandingv1.Features{
        Syntax: &naturallanguageunderstandingv1.SyntaxOptions{
          Sentences: &sentences,
          Tokens: &naturallanguageunderstandingv1.SyntaxOptionsTokens{
            Lemma:        &lemma,
            PartOfSpeech: &partOfSpeech,
          },
        },
      },
    },
  )
  if responseErr != nil {
    panic(responseErr)
  }
  b, _ := json.MarshalIndent(result, "", "   ")
  fmt.Println(string(b))
}

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("2022-04-07", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

String text = "With great power comes great responsibility"

SyntaxOptions syntax = new SyntaxOptions.Builder()
  .sentences(true)
  .build();

Features features = new Features.Builder()
  .syntax(syntax)
  .build();

AnalyzeOptions parameters = new AnalyzeOptions.Builder()
  .text(text)
  .features(features)
  .build();

AnalysisResults response = naturalLanguageUnderstanding
  .analyze(parameters)
  .execute()
  .getResult();
System.out.println(response);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '2022-04-07',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

const analyzeParams = {
  'features': {
    'syntax': {
      'sentences': true,
      'tokens': {
        'lemma': true,
        'part_of_speech': true
      }
    }
  },
  'text': 'With great power comes great responsibility'
};

naturalLanguageUnderstanding.analyze(analyzeParams)
  .then(analysisResults => {
    console.log(JSON.stringify(analysisResults, null, 2));
  })
  .catch(err => {
    console.log('error:', err);
  });

import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 \
    import Features, SyntaxOptions, SyntaxOptionsTokens

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='2022-04-07',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

response = natural_language_understanding.analyze(
    text='With great power comes great responsibility',
    features=Features(
      syntax=SyntaxOptions(
        sentences=True,
        tokens=SyntaxOptionsTokens(
          lemma=True,
          part_of_speech=True,
        )))).get_result()

print(json.dumps(response, indent=2))

require "json"
require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)

natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "2022-04-07",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

response = natural_language_understanding.analyze(
  text: "With great power comes great responsibility",
  features: {
    syntax: {
      sentences: true,
      tokens: {
        lemma: true,
        part_of_speech: true,
      }
    }
  }
)

puts JSON.pretty_generate(response.result)

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "2022-04-07", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

let text = "With great power comes great responsibility"
let tokens = SyntaxOptionsTokens(lemma: true, partOfSpeech: true)
let syntax = SyntaxOptions(sentences: true, tokens: tokens)
let features = Features(syntax: syntax)
naturalLanguageUnderstanding.analyze(features: features, text: text) {
  response, error in

  guard let analysis = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(analysis)
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var result = naturalLanguageUnderstanding.Analyze(
    text: "With great power comes great responsibility",
    features: new Features()
    {
        Syntax = new SyntaxOptions()
        {
            Sentences = true,
            Tokens = new SyntaxOptionsTokens()
            {
                Lemma = true,
                PartOfSpeech = true
            }
        }
    }
    );

Console.WriteLine(result.Response);

IamAuthenticator authenticator = new IamAuthenticator(
    Apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

NaturalLanguageUnderstandingService service = new NaturalLanguageUnderstandingService("2022-04-07", authenticator);

Features features = new Features()
{
    Syntax = new SyntaxOptions()
    {
        Sentences = true,
        Tokens = new SyntaxOptionsTokens()
        {
            PartOfSpeech = true,
            Lemma = true
        }
    }
};

naturalLanguageUnderstanding.Analyze(
    callback: (DetailedResponse<AnalysisResults> response, IBMError error) =>
    {
        Log.Debug("NaturalLanguageUnderstandingServiceV1", "Analyze result: {0}", response.Response);
    },
    text: "With great power comes great responsibility",
    features: features
);

{
  "usage": {
    "text_units": 1,
    "text_characters": 43,
    "features": 1
  },
  "syntax": {
    "tokens": [
      {
        "text": "With",
        "part_of_speech": "ADP",
        "location": [
          0,
          4
        ],
        "lemma": "with"
      },
      {
        "text": "great",
        "part_of_speech": "ADJ",
        "location": [
          5,
          10
        ],
        "lemma": "great"
      },
      {
        "text": "power",
        "part_of_speech": "NOUN",
        "location": [
          11,
          16
        ],
        "lemma": "power"
      },
      {
        "text": "comes",
        "part_of_speech": "VERB",
        "location": [
          17,
          22
        ],
        "lemma": "come"
      },
      {
        "text": "great",
        "part_of_speech": "ADJ",
        "location": [
          23,
          28
        ],
        "lemma": "great"
      },
      {
        "text": "responsibility",
        "part_of_speech": "NOUN",
        "location": [
          29,
          43
        ],
        "lemma": "responsibility"
      }
    ],
    "sentences": [
      {
        "text": "With great power comes great responsibility",
        "location": [
          0,
          43
        ]
      }
    ]
  },
  "language": "en"
}

curl -X POST -H "Content-Type: application/json" -u "apikey:{apikey}" -d @parameters.json "{url}/v1/analyze?version=2022-04-07"

{
  "url": "www.ibm.com",
  "features": {
    "summarization": {
      "limit": 2
    }
  }
}

{
  "usage": {
    "text_units": 1,
    "text_characters": 2922,
    "features": 0
  },
  "retrieved_url": "https://newsroom.ibm.com/Five-Things-IBM-Workday",
  "summarization": {
    "text": "Today, IBM and Workday, a leading provider of enterprise applications for human resources and finance, announced a joint solution designed to help companies begin the process of safely re-opening their workplaces. Here are five key takeaways from the announcement."
  },
  "language": "en"
}

curl -X {request_method} -u "apikey:{apikey}" "https://api.us-south.natural-language-understanding.watson.cloud.ibm.com/instances/{instance_id}"

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("{version}", authenticator);
naturalLanguageUnderstanding.setServiceUrl("https://api.us-east.natural-language-understanding.watson.cloud.ibm.com");

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: 'https://api.us-east.natural-language-understanding.watson.cloud.ibm.com',
});

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='{version}',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('https://api.us-east.natural-language-understanding.watson.cloud.ibm.com')

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "{version}",
  authenticator: authenticator
)
natural_language_understanding.service_url = "https://api.us-east.natural-language-understanding.watson.cloud.ibm.com"

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

if naturalLanguageUnderstandingErr != nil {
  panic(naturalLanguageUnderstandingErr)
}

naturalLanguageUnderstanding.SetServiceURL("https://api.us-east.natural-language-understanding.watson.cloud.ibm.com")

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "{version}", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "https://api.us-east.natural-language-understanding.watson.cloud.ibm.com"

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("https://api.us-east.natural-language-understanding.watson.cloud.ibm.com");

https://api.us-south.natural-language-understanding.watson.cloud.ibm.com

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("https://api.us-east.natural-language-understanding.watson.cloud.ibm.com");

curl -k -X {request_method} -u "apikey:{apikey}" "{url}/{method}"

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("{version}", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

HttpConfigOptions configOptions = new HttpConfigOptions.Builder()
  .disableSslVerification(true)
  .build();
naturalLanguageUnderstanding.configureClient(configOptions);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
  disableSslVerification: true,
});

from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='{version}',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

natural_language_understanding.set_disable_ssl_verification(True)

require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "{version}",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

natural_language_understanding.configure_http_client(disable_ssl_verification: true)

naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

if naturalLanguageUnderstandingErr != nil {
  panic(naturalLanguageUnderstandingErr)
}

naturalLanguageUnderstanding.SetServiceURL("{url}")

naturalLanguageUnderstanding.DisableSSLVerification()

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "{version}", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

naturalLanguageUnderstanding.disableSSLVerification()

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

naturalLanguageUnderstanding.DisableSslVerification(true);

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

naturalLanguageUnderstanding.DisableSslVerification = true;

curl -X {request_method} -u "apikey:{apikey}" "{url}/v1/{method}"

IamAuthenticator authenticator = new IamAuthenticator("{apikey}");
NaturalLanguageUnderstanding naturalLanguageUnderstanding = new NaturalLanguageUnderstanding("{version}", authenticator);
naturalLanguageUnderstanding.setServiceUrl("{url}");

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
});

from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

authenticator = IAMAuthenticator('{apikey}')
natural_language_understanding = NaturalLanguageUnderstandingV1(
    version='{version}',
    authenticator=authenticator
)

natural_language_understanding.set_service_url('{url}')

require "ibm_watson/authenticators"
require "ibm_watson/natural_language_understanding_v1"
include IBMWatson

authenticator = Authenticators::IamAuthenticator.new(
  apikey: "{apikey}"
)
natural_language_understanding = NaturalLanguageUnderstandingV1.new(
  version: "{version}",
  authenticator: authenticator
)
natural_language_understanding.service_url = "{url}"

import (
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)

func main() {
  authenticator := &core.IamAuthenticator{
    ApiKey: "{apikey}",
  }

  options := &naturallanguageunderstandingv1.NaturalLanguageUnderstandingV1Options{
    Version: "{version}",
    Authenticator: authenticator,
  }

  naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

  if naturalLanguageUnderstandingErr != nil {
    panic(naturalLanguageUnderstandingErr)
  }

  naturalLanguageUnderstanding.SetServiceURL("{url}")
}

let authenticator = WatsonIAMAuthenticator(apiKey: "{apikey}")
let naturalLanguageUnderstanding = NaturalLanguageUnderstanding(version: "{version}", authenticator: authenticator)
naturalLanguageUnderstanding.serviceURL = "{url}"

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

try {
  // Invoke a method
} catch (NotFoundException e) {
  // Handle Not Found (404) exception
} catch (RequestTooLargeException e) {
  // Handle Request Too Large (413) exception
} catch (ServiceResponseException e) {
  // Base class for all exceptions caused by error responses from the service
  System.out.println("Service returned status code "
    + e.getStatusCode() + ": " + e.getMessage());
}

naturalLanguageUnderstanding.method(params)
  .catch(err => {
    console.log('error:', err);
  });

from ibm_watson import ApiException
try:
    # Invoke a method
except ApiException as ex:
    print "Method failed with status code " + str(ex.code) + ": " + ex.message

require "ibm_watson"
begin
  # Invoke a method
rescue IBMWatson::ApiException => ex
  print "Method failed with status code #{ex.code}: #{ex.error}"
end

import "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"

// Instantiate a service
naturalLanguageUnderstanding, naturalLanguageUnderstandingErr := naturallanguageunderstandingv1.NewNaturalLanguageUnderstandingV1(options)

// Check for errors
if naturalLanguageUnderstandingErr != nil {
  panic(naturalLanguageUnderstandingErr)
}

// Call a method
result, _, responseErr := naturalLanguageUnderstanding.MethodName(&methodOptions)

// Check for errors
if responseErr != nil {
  panic(responseErr)
}

naturalLanguageUnderstanding.method() {
  response, error in

  if let error = error {
    switch error {
    case let .http(statusCode, message, metadata):
      switch statusCode {
      case .some(404):
        // Handle Not Found (404) exception
        print("Not found")
      case .some(413):
        // Handle Request Too Large (413) exception
        print("Payload too large")
      default:
        if let statusCode = statusCode {
          print("Error - code: \(statusCode), \(message ?? "")")
        }
      }
    default:
      print(error.localizedDescription)
    }
    return
  }

  guard let result = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }

  print(result)
}

try
{
    // Invoke a method
}
catch(ServiceResponseException e)
{
    Console.WriteLine("Error: " + e.Message);
}
catch (Exception e)
{
    Console.WriteLine("Error: " + e.Message);
}

// Invoke a method
naturalLanguageUnderstanding.MethodName(Callback, Parameters);

// Check for errors
private void Callback(DetailedResponse<ExampleResponse> response, IBMError error)
{
    if (error == null)
    {
        Log.Debug("ExampleCallback", "Response received: {0}", response.Response);
    }
    else
    {
        Log.Debug("ExampleCallback", "Error received: {0}, {1}, {3}", error.StatusCode, error.ErrorMessage, error.Response);
    }
}

curl -X {request_method} -H "Request-Header: {header_value}" "{url}/v1/{method}"

ReturnType returnValue = naturalLanguageUnderstanding.methodName(parameters)
  .addHeader("Custom-Header", "{header_value}")
  .execute();

const parameters = {
  {parameters}
};

naturalLanguageUnderstanding.methodName(
  parameters,
  headers: {
    'Custom-Header': '{header_value}'
  })
   .then(result => {
    console.log(response);
  })
  .catch(err => {
    console.log('error:', err);
  });

response = natural_language_understanding.methodName(
    parameters,
    headers = {
        'Custom-Header': '{header_value}'
    })

response = natural_language_understanding.headers(
  "Custom-Header" => "{header_value}"
).methodName(parameters)

result, _, responseErr := naturalLanguageUnderstanding.MethodName(
  &methodOptions{
    Headers: map[string]string{
      "Accept": "application/json",
    },
  },
)

let customHeader: [String: String] = ["Custom-Header": "{header_value}"]
naturalLanguageUnderstanding.methodName(parameters, headers: customHeader) {
  response, error in
}

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

naturalLanguageUnderstanding.WithHeader("Custom-Header", "header_value");

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

naturalLanguageUnderstanding.WithHeader("Custom-Header", "header_value");

curl -X {request_method} {authentication_method} --include "{url}/v1/{method}"

Response<ReturnType> response = naturalLanguageUnderstanding.methodName(parameters)
  .executeWithDetails();
// Access response from methodName
ReturnType returnValue = response.getResult();
// Access information in response headers
Headers responseHeaders = response.getHeaders();

naturalLanguageUnderstanding.methodName(parameters)
  .then(response => {
    console.log(response.headers);
  })
  .catch(err => {
    console.log('error:', err);
  });

natural_language_understanding.set_detailed_response(True)
response = natural_language_understanding.methodName(parameters)
# Access response from methodName
print(json.dumps(response.get_result(), indent=2))
# Access information in response headers
print(response.get_headers())
# Access HTTP response status
print(response.get_status_code())

response = natural_language_understanding.methodName(parameters)
# Access response from methodName
print response.result
# Access information in response headers
print response.headers
# Access HTTP response status
print response.status

import (
  "github.com/IBM/go-sdk-core/core"
  "github.com/watson-developer-cloud/go-sdk/naturallanguageunderstandingv1"
)
result, response, responseErr := naturalLanguageUnderstanding.MethodName(
  &methodOptions{})
// Access result
core.PrettyPrint(response.GetResult(), "Result ")

// Access response headers
core.PrettyPrint(response.GetHeaders(), "Headers ")

// Access status code
core.PrettyPrint(response.GetStatusCode(), "Status Code ")

naturalLanguageUnderstanding.methodName(parameters) {
  response, error in

  guard let result = response?.result else {
    print(error?.localizedDescription ?? "unknown error")
    return
  }
  print(result) // The data returned by the service
  print(response?.statusCode)
  print(response?.headers)
}

var results = naturalLanguageUnderstanding.MethodName(parameters);

var result = results.Result;            //  The result object
var responseHeaders = results.Headers;  //  The response headers
var responseJson = results.Response;    //  The raw response JSON
var statusCode = results.StatusCode;    //  The response status code

private void Example()
{
    naturalLanguageUnderstanding.MethodName(Callback, Parameters);
}

private void Callback(DetailedResponse<ResponseType> response, IBMError error)
{
    var result = response.Result;                 //  The result object
    var responseHeaders = response.Headers;       //  The response headers
    var responseJson = reresponsesults.Response;  //  The raw response JSON
    var statusCode = response.StatusCode;         //  The response status code
}

curl -u "apikey:{apikey}" -H "X-Watson-Learning-Opt-Out: true" "{url}/{method}"

Map<String, String> headers = new HashMap<String, String>();
headers.put("X-Watson-Learning-Opt-Out", "true");

naturalLanguageUnderstanding.setDefaultHeaders(headers);

const NaturalLanguageUnderstandingV1 = require('ibm-watson/natural-language-understanding/v1');
const { IamAuthenticator } = require('ibm-watson/auth');

const naturalLanguageUnderstanding = new NaturalLanguageUnderstandingV1({
  version: '{version}',
  authenticator: new IamAuthenticator({
    apikey: '{apikey}',
  }),
  serviceUrl: '{url}',
  headers: {
    'X-Watson-Learning-Opt-Out': 'true'
  }
});

natural_language_understanding.set_default_headers({'x-watson-learning-opt-out': "true"})

natural_language_understanding.add_default_headers(headers: {"x-watson-learning-opt-out" => "true"})

import "net/http"

headers := http.Header{}
headers.Add("x-watson-learning-opt-out", "true")
naturalLanguageUnderstanding.SetDefaultHeaders(headers)

naturalLanguageUnderstanding.defaultHeaders["X-Watson-Learning-Opt-Out"] = "true"

IamAuthenticator authenticator = new IamAuthenticator(
    apikey: "{apikey}"
    );

NaturalLanguageUnderstandingService naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

naturalLanguageUnderstanding.WithHeader("X-Watson-Learning-Opt-Out", "true");

var authenticator = new IamAuthenticator(
    apikey: "{apikey}"
);

while (!authenticator.CanAuthenticate())
    yield return null;

var naturalLanguageUnderstanding = new NaturalLanguageUnderstandingService("{version}", authenticator);
naturalLanguageUnderstanding.SetServiceUrl("{url}");

naturalLanguageUnderstanding.WithHeader("X-Watson-Learning-Opt-Out", "true");