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

# Search

GET https://quippe.medicomp.com/api/Quippe/Coding/Search/Search

Searches medical code descriptions across many vocabularies at once and returns the matching codes, ranked by relevance. Given free text such as "headache", the Code Search API (GET /Quippe/Coding/Search/Search) searches the descriptions of codes in vocabularies including SNOMED CT, ICD-10-CM, ICD-9-CM, MEDCIN, LOINC, RxNorm, CPT, MeSH, and CTCAE, and returns each matching code with its vocabulary, description, and rank. Optionally it can also return the MEDCIN findings each code maps to. 

 Common uses include code lookup and autocomplete by description, finding the right billing or problem-list code from a clinical phrase, and cross-vocabulary code discovery. 

 GET /Quippe/Coding/Search/Search 

Use this endpoint when you have descriptive text and want codes. MEDCIN can appear among the results but is not the focus. To search the MEDCIN clinical terminology specifically and get back MEDCIN terms, use [/Quippe/Search](/api-reference/rest/get-quippe-search). To translate a code you already have into another vocabulary, use [/Quippe/Coding/TranslateItem](/api-reference/rest/get-quippe-coding-translate-item).

Reference: https://docs.medicomp.com/api-reference/rest/get-quippe-coding-search-search

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

- `Query` (string, required) — The free-text search query to match against code descriptions, such as "headache" or "chest pain".
- `VocabCodes` (string, optional) — Comma-separated list of vocabulary codes to restrict the search to (for example snomed,icd10,loinc). When omitted, the service's default set of vocabularies is searched and results are merged and ranked together. Each code must be licensed. The full list of supported vocabulary codes can be retrieved from the [/Quippe/Coding/Vocabs](/api-reference/rest/get-quippe-coding-vocabs) endpoint. Note that "icd" is ICD-9-CM and "icd10" is ICD-10-CM.
- `TermType` (string, optional) — Restricts results to a single term type within the searched vocabularies. Term-type codes are vocabulary-specific (for example RxNorm term types are upper-cased before use). Defaults to the service default term type; leave at the default to search all term types.
- `Limit` (integer, optional) — Maximum number of matches to return. Defaults to 100; valid range is 1 to the upper limit supported by the service or provider.
- `Exact` (boolean, optional) — When true, uses the query as-is (applying only the minimal required pre-processing) and disables the automatic suggestions (term suggestion and spell-correction).
- `Clean` (boolean, optional) — When true, removes punctuation from the query in addition to the minimal required pre-processing.
- `Verbose` (boolean, optional) — When true, returns additional detail per match: a Score, plus CodeInfo (code id, vocab version, matched description, hint/specifier/unreportable flags) and DescriptionInfo (description id, type, sequence, word and character counts).
- `SortMode` (enum, optional) — Orders results either by relevance/search-score rank or in vocabulary order. Defaults to the service default sort mode. (Applies to the merged result set when multiple vocabularies are searched.)
  - Allowed values: `Rank`, `VocabRank`, `VocabHierarchy`, `VocabDescription`, `VocabCode`
- `IncludeMedcinMaps` (enum, optional) — Whether to include the MEDCIN findings that each non-MEDCIN match maps to, added as a MedcinMaps block per match. None (default) omits them; All includes every available map; Limited includes only the best-choice maps. MEDCIN matches themselves are never given a map block.
  - Allowed values: `None`, `All`, `Limited`
- `Tags` (string, optional) — Comma-separated list of tag sets to evaluate and attach to matches (via the MEDCIN findings a code maps to), returned in a per-match Tags attribute.
- `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.

## Response

### 200

Successful response

- `matches` (object, optional)
  - `match` (list of object, optional)
    - `codeInfo` (object, optional)
      - `id` (integer, optional)
      - `vocabVersion` (string, optional)
      - `matchedDescription` (string, optional)
      - `vocabExtensionCode` (string, optional)
      - `hasHints` (boolean, optional)
      - `hasSpecifiers` (boolean, optional)
      - `unreportable` (boolean, optional)
    - `descriptionInfo` (object, optional)
      - `id` (integer, optional)
      - `typeId` (integer, optional)
      - `sequence` (integer, optional)
      - `wordCount` (integer, optional)
      - `charCount` (integer, optional)
    - `medcinMap` (object, optional)
      - `medcinId` (integer, optional)
      - `prefix` (string, optional)
      - `result` (string, optional)
      - `relationship` (string, optional)
    - `rank` (integer, optional)
    - `culture` (string, optional)
    - `vocab` (string, optional)
    - `code` (string, optional)
    - `termType` (string, optional)
    - `nodekey` (string, optional)
    - `description` (string, optional)
    - `tags` (string, optional)
    - `score` (double, optional)
  - `matchExpression` (string, optional)
  - `time` (integer, optional)
  - `count` (integer, optional)

## Examples

**Response**

```json
{
  "matches": {
    "match": [
      {
        "codeInfo": {
          "id": 0,
          "vocabVersion": "",
          "matchedDescription": "",
          "vocabExtensionCode": "",
          "hasHints": "",
          "hasSpecifiers": "",
          "unreportable": ""
        },
        "descriptionInfo": {
          "id": 0,
          "typeId": 0,
          "sequence": 0,
          "wordCount": 0,
          "charCount": 0
        },
        "medcinMap": {
          "medcinId": 0,
          "prefix": "",
          "result": "",
          "relationship": ""
        },
        "rank": 1,
        "culture": "en-US",
        "vocab": "snomed",
        "code": "279016001",
        "termType": "finding",
        "nodekey": "-AAA-L",
        "description": "Cervicogenic headache (finding)",
        "tags": "",
        "score": 0
      }
    ],
    "matchExpression": "",
    "time": 136,
    "count": 66
  }
}
```

**SDK Code**

```python
import requests

url = "https://quippe.medicomp.com/api/Quippe/Coding/Search/Search"

querystring = {"Query":"Query"}

response = requests.get(url, params=querystring, auth=("<username>", "<password>"))

print(response.json())
```

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

const options = {method: 'GET', headers: {Authorization: `Basic ${credentials}`}};

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/Coding/Search/Search?Query=Query"

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

	req.SetBasicAuth("<username>", "<password>")

	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/Coding/Search/Search?Query=Query")

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

request = Net::HTTP::Get.new(url)
request.basic_auth("<username>", "<password>")

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.get("https://quippe.medicomp.com/api/Quippe/Coding/Search/Search?Query=Query")
  .basicAuth("<username>", "<password>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://quippe.medicomp.com/api/Quippe/Coding/Search/Search?Query=Query', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

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

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

var client = new RestClient("https://quippe.medicomp.com/api/Quippe/Coding/Search/Search?Query=Query");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.GET);

IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://quippe.medicomp.com/api/Quippe/Coding/Search/Search?Query=Query")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
```