> 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.

# Score Chart

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

Scores a patient's charted findings against the conditions (diagnoses) present in the same chart, flagging which documented findings support or relate to which conditions. Also known as clinical documentation improvement (CDI) scoring or clinical relevance scoring, the ScoreChart API (POST /Quippe/ClinicalLens/ScoreChart) takes a chart of coded entries, identifies condition (diagnosis) entries within it, uses MEDCIN prompting logic to build small/large/full lists of findings clinically associated with each condition, and annotates every non-condition finding in the chart with the conditions it supports. 

 Common uses include clinical documentation improvement (CDI) review, surfacing evidence in a note that justifies a billed or coded diagnosis, and highlighting findings that appear unrelated to any documented condition. 

 POST /Quippe/ClinicalLens/ScoreChart 

 The request body's coded entries are supplied and returned via the shared `CodedEntries` schema (the same coded-chart shape used elsewhere in the API). For each condition entry found in the chart (or, if `Sources` is supplied, for each MEDCIN ID, external code, or content library item listed there instead), three MEDCIN prompt lists are built: a small list, a large list, and a full list. Every other finding in the chart is compared against these lists, and when a match is found an `AssociatedFindings/Finding` is appended to that finding's entry, carrying the matched condition's code, vocabulary, and a `Score` of 1, 2, or 3 indicating whether the match came from the small, large, or full prompt list respectively (lower scores indicate a tighter clinical association). Prompt lists can be overridden per condition by tagged content library items (see `UseContentOverride` and `ContentPrefix`) instead of the built-in MEDCIN prompting logic. 

 A finding that matches no condition's prompt lists is left without an `AssociatedFindings` rather than causing an error, so callers should treat a missing element as "unrelated to any documented condition" rather than a failure. When a source entry also matches a content library item (rather than only the built-in MEDCIN logic), the finding additionally gets an `AssociatedContentLibraryItems/Item` identifying the matching content library item(s) by ID and name.

Reference: https://docs.medicomp.com/api-reference/rest/post-quippe-clinical-lens-score-chart

## 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

- `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)

- `CodedEntriesXML` (string, required) — Coded data from the patient's chart that we want to score.
- `UseContentOverride` (boolean, optional) — Flag indicating whether you wish to look in the user's content library for custom prompt lists that have been tagged to override the default MEDCIN prompting logic for a given MEDCIN ID.
- `BroadPromptMethod` (integer, optional) — When developing the scoring for level 3 (the broad prompt), this controls the logic that we use. 0 or 1 means we match any specialties for the chart item against any specialties for the condition. 2 means we match any specialties for the chart item against the primary specialty for the condition. 3 means we match against any items in the ICD10WHO category for the condition.
- `IncludeMedcinMetadata` (boolean, optional) — Flag indicating whether you want the mapped MEDCIN ID and prefix to be included in the response data.
- `ExpandOnAllDx` (boolean, optional) — When you prompt on a condition that is simply a pointer to a set of other conditions, this flag controls whether we combine the prompt results for all of those other conditions.
- `ContentPrefix` (string, optional) — When looking in the user's content library for custom prompt lists, this is the prefix that should be used when searching for tags that indicate a custom prompt list.
- `ExpandLabPanels` (boolean, optional) — Flag indicating whether we should expand lab panels in the prompt results to include the components of the lab panel.
- `Sources` (string, optional) — List of sources that the chart data should be scored against. If this is not specified, we look for conditions in the provided chart data. If it is specified, it can be a comma separated list of MEDCIN IDs, external codes (in the format of "vocab_code:code"), or content library item IDs.

## Response

### 200

Successful response

- `codedEntries` (object or object, optional)
  - object
    - `group` (object, optional)
      - `entry` (list of object, optional)
        - `associatedFindings` (list of object or object, optional)
          - Quippe.ClinicalLens.ScoreChart.Finding.JSON
            - `vocab` (string, optional)
            - `version` (string, optional)
            - `code` (string, optional)
            - `description` (string, optional)
            - `medcinId` (integer, optional)
            - `score` (integer, optional)
        - `associatedContentLibraryItems` (list of object or object, optional)
          - Quippe.ClinicalLens.ScoreChart.Item.JSON
            - `id` (string, optional)
            - `name` (string, optional)
        - `id` (string, optional)
        - `vocab` (string, optional)
        - `version` (string, optional)
        - `code` (string, optional)
        - `description` (string, optional)
        - `medcinId` (integer, optional)
        - `prefix` (string, optional)
      - `vocab` (string, optional)
      - `version` (string, optional)
  - object
    - `entry` (object, optional)
      - `associatedFindings` (list of object or object, optional)
        - Quippe.ClinicalLens.ScoreChart.Finding.JSON
          - `vocab` (string, optional)
          - `version` (string, optional)
          - `code` (string, optional)
          - `description` (string, optional)
          - `medcinId` (integer, optional)
          - `score` (integer, optional)
      - `associatedContentLibraryItems` (list of object or object, optional)
        - Quippe.ClinicalLens.ScoreChart.Item.JSON
          - `id` (string, optional)
          - `name` (string, optional)
      - `id` (string, optional)
      - `vocab` (string, optional)
      - `version` (string, optional)
      - `code` (string, optional)
      - `description` (string, optional)
      - `medcinId` (integer, optional)
      - `prefix` (string, optional)

## Examples

**Request**

```json
{
  "CodedEntriesXML": "string"
}
```

**Response**

```json
{
  "codedEntries": {
    "group": {
      "entry": [
        {
          "associatedFindings": [
            {
              "vocab": "string",
              "version": "string",
              "code": "string",
              "description": "string",
              "medcinId": 1,
              "score": 1
            }
          ],
          "associatedContentLibraryItems": [
            {
              "id": "string",
              "name": "string"
            }
          ],
          "id": "string",
          "vocab": "string",
          "version": "string",
          "code": "string",
          "description": "string",
          "medcinId": 1,
          "prefix": "string"
        }
      ],
      "vocab": "string",
      "version": "string"
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://quippe.medicomp.com/api/Quippe/ClinicalLens/ScoreChart"

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/ClinicalLens/ScoreChart';
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/ClinicalLens/ScoreChart"

	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/ClinicalLens/ScoreChart")

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/ClinicalLens/ScoreChart")
  .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/ClinicalLens/ScoreChart', [
  '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/ClinicalLens/ScoreChart");
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/ClinicalLens/ScoreChart")! 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()
```