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

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

Scores the documentation quality of a clinical note (chart note scoring / documentation completeness scoring) for one or more diagnoses. Given a chart and a set of diagnosis MEDCIN IDs — or, if none are supplied, the diagnoses already coded in the chart — the ScoreNote API (POST /Quippe/ChartReview/ScoreNote) checks whether the chart contains Subjective, Objective, Assessment, and Plan (SOAP) evidence supporting each diagnosis and returns a numeric score along with the record IDs that contributed to it. 

 Common uses include clinical documentation improvement (CDI) review, auditing a note for missing SOAP elements before signing, and flagging diagnoses that lack supporting documentation. 

 POST /Quippe/ChartReview/ScoreNote 

For each evaluated diagnosis, the score is 0 when no Assessment (SOAPCategory "A") evidence is found; 1 when Assessment evidence exists but Subjective, Objective, and Plan are not all present; and 2 when all four SOAP categories (S, O, A, P) are present. The score is further incremented by 1 when the note also qualifies for a higher-complexity E/M level, so the maximum score is 3. The response is a `NoteScores` element containing one `Item` per evaluated diagnosis, each with the diagnosis `MedcinId`, its `Text` description, the computed `Score`, and a comma-separated `TargetIds` list of the chart record IDs that were counted as evidence.

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

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

- `Chart` (string, required) — The chart note to score, as XML (or another format recognized via `InputFormat`). Passed to the ScoreNote API and parsed into its constituent records before scoring; parsing failures cause the request to fail with an error describing the parse problem.
- `Diagnoses` (string, optional) — A list of diagnosis MEDCIN IDs to score the chart against. If not specified, the diagnoses already coded as an unqualified, non-negated Assessment (SOAPCategory "A") in the chart are used instead. If no diagnoses are supplied and none can be found in the chart, the ScoreNote API returns an empty `NoteScores` result.
- `ScoringMethod` (integer, optional) — Reserved for selecting an alternate scoring algorithm. Accepted but not currently applied by the ScoreNote API, which always uses its default SOAP-category scoring.
- `InputFormat` (string, optional) — Indicates the mime type of the `Chart` input parameter, such as "application/vnd.medicomp.quippe.note+xml". If left blank, the ScoreNote API attempts to deduce the format from the content of `Chart`.

## Response

### 200

Successful response

- `noteScores` (list of object, optional)
  - `medcinId` (integer, optional)
  - `text` (string, optional)
  - `score` (double, optional)
  - `targetIds` (string, optional)

## Examples

**Request**

```json
{
  "Chart": "string"
}
```

**Response**

```json
{
  "noteScores": [
    {
      "medcinId": 1,
      "text": "string",
      "score": 1.1,
      "targetIds": "string"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://quippe.medicomp.com/api/Quippe/ChartReview/ScoreNote"

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/ChartReview/ScoreNote';
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/ChartReview/ScoreNote"

	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/ChartReview/ScoreNote")

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