> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.medicomp.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.medicomp.com/_mcp/server.

# Recognize

POST https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize
Content-Type: application/x-www-form-urlencoded

Recognizes structured medical terminology within free-text clinical notes — clinical natural-language processing (NLP), also described as medical named-entity recognition (NER) or automated clinical text encoding. Given the text of a patient note, the Recognize API (POST /Quippe/TextRecognition/Recognize) locates medical concepts in the text and returns each as a MEDCIN finding tagged with its character position and a confidence score, so narrative documentation can be turned into coded, structured clinical data. The findings this returns can then be mapped to standard vocabularies (ICD-10, SNOMED CT, CPT, and others) using the coding endpoints. 

 Common uses include converting plain text to codes, extracting problems, symptoms, medications, and findings from dictated/ambient listening or typed notes, and structuring free text captured in an EHR. 

 POST /Quippe/TextRecognition/Recognize 

This endpoint is the front of the coding pipeline: free text in, MEDCIN findings out. To then map those findings to other vocabularies, use [/Quippe/Coding/ChartMap](/api-reference/rest/post-quippe-coding-chart-map) for a whole chart of findings, or [/Quippe/Coding/TranslateItem](/api-reference/rest/get-quippe-coding-translate-item) for a single code. To search the MEDCIN terminology directly instead of recognizing it from prose, use [/Quippe/Search](/api-reference/rest/get-quippe-search).

Reference: https://docs.medicomp.com/api-reference/rest/post-quippe-text-recognition-recognize

## Authentication

- `Authorization` header (basic auth, required) — Login and password used to access quippe.medicomp.com. On-premise Quippe deployments can be configured to use whatever authentication and authorization your application is configured for, so basic authentication is used here to access the Quippe sandbox and is not a product requirement.
- `Authorization` header (bearer token, required) — JSON web token generated by a request to the [/Quippe/Security/Token](/api-reference/rest/get-quippe-security-token) web service endpoint in Quippe.

## Request

### Query parameters

- `ResolveFindings` (boolean, optional) — When true (default), resolves each recognized finding through the NoteBuilder, enriching results with additional structure (nodeKey, term type, phrasing, and refined display text) as they would appear in a built note. Set false to return raw recognition results without the resolve pass.
- `DataFormat` (enum, optional) — Specifies how objects are encoded in the output
  - Allowed values: `Default`, `XML`, `JSON`, `JSF`
- `RequestId` (string, optional) — Optional value that can be used by clients to track multiple requests.
- `Culture` (string, optional) — Culture to use when handling the request. If not specified the default value configured on the server will be used.

### Body (application/x-www-form-urlencoded)

- `Text` (string, required) — The clinical text to analyze — typically a patient note or a section of one, as plain text.
- `DocumentType` (string, optional) — Document type of the note (for example a progress note or H&P), used as context to guide recognition.
- `DocumentSection` (string, optional) — Identifier of the section within the document that the text came from (for example an HPI or assessment section), used as recognition context.
- `ServiceType` (string, optional) — Type of service being provided, using service codes from the E/M guidelines, used as recognition context. The list of valid service codes is available at /Medcin/Enums/Services.
- `ClinicalSetting` (string, optional) — Clinical setting where the service is provided (for example inpatient or emergency department), using setting codes from the E/M guidelines, used as recognition context. The list of valid setting codes is available at /Medcin/Enums/Settings.
- `ProvideRole` (string, optional) — Role of the provider authoring the note, used as recognition context.
- `ProviderSpecialty` (string, optional) — Provider specialty, used as recognition context to bias results toward specialty-relevant findings. The list of valid specialty codes is available at /Medcin/Enums/Specialty.
- `PatientId` (string, optional) — Patient identifier, used to look up patient age and sex from the configured patient data provider so recognition can apply age- and sex-appropriate context. Requires an IPatientDataService.
- `EncounterTime` (string, optional) — Eencounter date/time, used with PatientId to compute the patient's age at the time of the encounter. Defaults to the current time when a patient is resolved.
- `RecognitionProvider` (string, optional) — Name of the text-recognition provider to use, for installations configured with more than one. Leave blank (default) to use the default provider.
- `Settings` (string, optional) — Provider-specific recognition settings, supplied as a JSON object. The accepted keys depend on the selected RecognitionProvider. Defaults to none.

## Response

### 200

Successful response

- `taggedText` (object, optional)
  - `text` (string, required)
  - `results` (list of object or object, required)
    - Quippe.TextRecognition.Recognize.Result.JSON
      - `alternates` (list of object, optional)
        - `medcinId` (integer, optional)
        - `prefix` (string, optional)
        - `result` (string, optional)
        - `modifier` (string, optional)
        - `status` (string, optional)
        - `value` (string, optional)
        - `unit` (string, optional)
        - `notation` (string, optional)
      - `index` (integer, optional)
      - `length` (integer, optional)
      - `confidence` (double, optional)
      - `medcinId` (integer, optional)
      - `prefix` (string, optional)
      - `result` (string, optional)
      - `modifier` (string, optional)
      - `status` (string, optional)
      - `value` (string, optional)
      - `unit` (string, optional)
      - `notation` (string, optional)
      - `description` (string, optional)

## Examples

**Request**

```json
{
  "Text": "string"
}
```

**Response**

```json
{
  "taggedText": {
    "text": "string",
    "results": [
      {
        "alternates": [
          {
            "medcinId": 10,
            "prefix": "",
            "result": "",
            "modifier": "",
            "status": "",
            "value": "",
            "unit": "",
            "notation": ""
          }
        ],
        "index": 14,
        "length": 8,
        "confidence": 0,
        "medcinId": 10,
        "prefix": "",
        "result": "A",
        "modifier": "",
        "status": "",
        "value": "",
        "unit": "",
        "notation": "",
        "description": "headache"
      }
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize"

payload = ""
headers = {
    "Content-Type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript
const url = 'https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  body: new URLSearchParams('')
};

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

```go
package main

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

func main() {

	url := "https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize"

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

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize")

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

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/x-www-form-urlencoded'

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/x-www-form-urlencoded")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize', [
  'form_params' => null,
  'headers' => [
    'Content-Type' => 'application/x-www-form-urlencoded',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/x-www-form-urlencoded");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/x-www-form-urlencoded"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://quippe.medicomp.com/api/Quippe/TextRecognition/Recognize")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```