Accept an XML response

<entry_list version="1.0">
  <entry id="motivation">
    <ew>motivation</ew>
    <subj>PS</subj>
    <hw>mo*ti*va*tion</hw>
    <sound>
      <wav>motiva04.wav</wav>
      <wpr>+mO-tu-!vA-shun</wpr>
    </sound>
    <pr>ˌmō-tə-ˈvā-shən</pr>
    <fl>noun</fl>
    <def>
      <date>1873</date>
      <sn>1 a</sn>
      <dt>:the act or process of <fw>motivating</fw></dt>
      <sn>b</sn>
      <dt>:the condition of being <fw>motivated</fw></dt>
      <sn>2</sn>
      <dt>:a motivating force, stimulus, or influence :
        <sx>incentive</sx>
        <sx>drive</sx>
      </dt>
    </def>
    <uro>
      <ure>mo*ti*va*tion*al</ure>
      <sound>
        <wav>motiva05.wav</wav>
        <wpr>+mO-tu-!vA-shu-n/ul</wpr>
      </sound>
      <pr>-shnəl, -shə-nᵊl</pr>
      <fl>adjective</fl>
    </uro>
    <uro>
      <ure>mo*ti*va*tion*al*ly</ure>
      <fl>adverb</fl>
    </uro>
  </entry>
</entry_list>

#r "Newtonsoft.Json"

using System.Net;
using System.Xml;
using Newtonsoft.Json;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log)
{
  log.Info($"C# HTTP trigger function processed a request. RequestUri={req.RequestUri}");

  // the api key to be used against the Dictionary API
  string apiKey = req.GetQueryNameValuePairs()
    .FirstOrDefault(q => string.Compare(q.Key, "APIKEY", true) == 0)
    .Value;

  // the word to check 
  string word = req.GetQueryNameValuePairs()
    .FirstOrDefault(q => string.Compare(q.Key, "word", true) == 0)
    .Value;

  var worddef = await GetWordDefinition(word, apiKey);
 
  return req.CreateResponse(HttpStatusCode.OK, worddef, "application/json");
}

/// <summary>
/// The getdef() method calls the API and retrieves the definition as JSON.
/// </summary>
/// <param name="word">The word looked up in the dictionary.</param>
/// <param name="key">The Dictionary.com API Key.</param>
/// <returns></returns>
public static async Task<Word> GetWordDefinition(string word, string apiKey)
{
  // established variables used in the method to make the call
  string endpointroot = "http://www.dictionaryapi.com/api/v1/references/collegiate/xml/";
  string apifrag = "?key=";
  string dictionarycall = endpointroot + word + apifrag + apiKey;

  // Call the dictionary API and read the response back
  HttpClient client = new HttpClient();
  var request = new HttpRequestMessage(HttpMethod.Post, dictionarycall);
  request.Headers.Add("cache-control", "no-cache");
  var response = await client.SendAsync(request);
  string wordres = await response.Content.ReadAsStringAsync();

  // Retrive the values from the response
  XmlDocument wordxml = new XmlDocument();
  wordxml.LoadXml(wordres);

  XmlNode root = wordxml.DocumentElement;
  XmlNode nodename = root.SelectSingleNode("/entry_list/entry[1]/ew");
  XmlNode nodepart = root.SelectSingleNode("/entry_list/entry[1]/fl");
  XmlNode nodedefinition = root.SelectSingleNode("/entry_list/entry[1]/def/dt[1]");

  // Instantiate a word object and assign the values from the response.
  Word wordobj = new Word();
  wordobj.name = nodename.InnerXml;
  wordobj.part = nodepart.InnerXml;
  wordobj.definition = nodedefinition.InnerXml;

  return wordobj;
}

/// <summary>
/// The word object holds the key attributes for a word definition.
/// </summary>
internal class Word
{
  public string name { get; set; }
  public string part { get; set; }
  public string definition { get; set; }
}

{
    "swagger": "2.0",
    "info": {
        "version": "1.0.0",
        "title": "Get Definition"
    },
    "schemes": [ "https" ],
    "host": "prdhlpsmpfncwus01.azurewebsites.net",
    "basePath": "/api",
    "paths": {
        "/DictionaryConnector": {
            "post": {
                "tags": [ "Websters Dictionary API" ],
                "summary": "Get a word definition.",
                "description": "Returns a definition for a word.",
                "operationId": "getDefinition",
                "x-ntx-summary": "Get a word definition",
                "parameters": [
                    {
                        "name": "word",
                        "in": "query",
                        "description": "The word to define",
                        "x-ntx-summary": "Word to define.",
                        "required": true,
                        "type": "string"
                    }
                ],
                "produces": [ "application/json" ],
                "security": [
                    {
                        "dictionaryApiKey": []
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with definition object.",
                        "schema": {
                            "title": "definition object",
                            "type": "object",
                            "properties": {
                                "word": {
                                    "type": "string",
                                    "x-ntx-visibility": "internal"
                                },
                                "part": {
                                    "type": "string",
                                    "x-ntx-visibility": "internal"
                                },
                                "definition": {
                                    "type": "string",
                                    "x-ntx-summary": "Definition"
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    "securityDefinitions": {
        "dictionaryApiKey": {
            "type": "apiKey",
            "name": "APIKEY",
            "in": "query"
        }
    }
}