# io.github.CloudCorpRecords/medprice (npm · @reneturcios/medprice)

Compare US prescription prices by pharmacy, find nearby pharmacies and drug equivalents.

- Trust score: 66/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `@reneturcios/medprice`: 66/100 (this document), [markdown](https://verifymcp.io/servers/cloudcorprecords-medprice/reneturcios-medprice.md), [page](https://verifymcp.io/servers/cloudcorprecords-medprice/reneturcios-medprice)
- oci · `ghcr.io/cloudcorprecords/medprice`: 37/100, [markdown](https://verifymcp.io/servers/cloudcorprecords-medprice/ghcr-io-cloudcorprecords-medprice.md), [page](https://verifymcp.io/servers/cloudcorprecords-medprice/ghcr-io-cloudcorprecords-medprice)

## Channel facts

- Registry: `npm`
- Package: `@reneturcios/medprice`
- Version: `0.1.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 30 of 92 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 62/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5094 tokens (~283/item across 18 items; 18 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "get_transfer_steps" implies "transfer" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 18 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.CloudCorpRecords/medprice MCP server?

io.github.CloudCorpRecords/medprice runs locally as an npm package, launched with npx -y @reneturcios/medprice. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add cloudcorprecords-medprice -- npx -y @reneturcios/medprice
```

### Cursor

```json
{
  "mcpServers": {
    "cloudcorprecords-medprice": {
      "command": "npx",
      "args": [
        "-y",
        "@reneturcios/medprice"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "cloudcorprecords-medprice": {
      "command": "npx",
      "args": [
        "-y",
        "@reneturcios/medprice"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add cloudcorprecords-medprice -- npx -y @reneturcios/medprice
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cloudcorprecords-medprice": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@reneturcios/medprice"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cloudcorprecords-medprice --command npx --arg -y --arg @reneturcios/medprice
```

### Hermes

```yaml
mcp_servers:
  cloudcorprecords-medprice:
    command: "npx"
    args: ["-y", "@reneturcios/medprice"]
```

### Netclaw

```json
{
  "McpServers": {
    "cloudcorprecords-medprice": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@reneturcios/medprice"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add cloudcorprecords-medprice -t stdio -c npx -a -y @reneturcios/medprice
```

### Other

```json
{
  "mcpServers": {
    "cloudcorprecords-medprice": {
      "command": "npx",
      "args": [
        "-y",
        "@reneturcios/medprice"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 66)

First indexed and scored.

## MCP tools (18)

### `compare_prices` (~546 tokens)

Price of one medicine with the free FineRx card at US pharmacy chains, near a place.

    Use when the person asks what a medicine costs, where it costs less, or its
    price near them or in a ZIP code. ``drug`` is a name as typed or a slug from
    search_drugs; ``strength`` ("10 mg"), ``form`` ("tablet") and ``quantity``
    are optional (the package with the most chains priced is used). ``zip`` is a
    5-digit US ZIP — pass it only when the person gave one; without it the host's
    approximate location is used when there is one, else the answer is national
    and asks for a ZIP. ``ndc`` (+ ``quantity``) is accepted for older callers.
    ``compare_to`` is a dollar amount the person named for THIS package — their
    insurance copay, what they pay now, or a price they want to hear about —
    and the answer then says how many chains were seen below it.

    Returns the package, every chain's card price with its observation date
    (Walmart per state), the nearest store of each chain with a store nearby,
    chains with a card price but no store nearby, coverage (``other_quantities``
    lists the pack sizes that were seen), and the card: codes, the dated price
    with the card, and the card sentence.

    Next: quote each price with its date and chain; say the price is set per
    chain; then the card sentence and codes.

Input parameters:

- `channel`: An optional channel tag identifying where the request comes through; leave it out unless the calling host supplies one.
- `compare_to`: A dollar amount the person named for this package (their insurance copay, what they pay now, or a price they want to beat); the answer then says how many chains were seen below it.
- `drug`: The medicine: a name as typed, or a slug from search_drugs.
- `form`: The dosage form of the medicine (e.g. "tablet").
- `locale`: A language code for the answer (the host's own is used when left out).
- `ndc`: The medicine's NDC (National Drug Code); accepted together with quantity for older callers.
- `quantity`: The quantity to price (the pack size / number of units).
- `strength`: The strength of the medicine (e.g. "10 mg").
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `ui_prices` (~277 tokens)

Card prices for another dose, quantity or place — called by the FineRx card itself.

    Same answer as compare_prices, for the package and place picked inside the
    card. ``where`` is the place as typed in the card (a ZIP, a city or an
    address): used for this one request, never stored. Not for the model.

Input parameters:

- `compare_to`: A dollar amount the person named for this package (their insurance copay, what they pay now, or a price they want to beat); the answer then says how many chains were seen below it.
- `form`: The dosage form of the medicine (e.g. "tablet").
- `locale`: A language code for the answer (the host's own is used when left out).
- `quantity`: The quantity to price (the pack size / number of units).
- `slug` (string, required): The slug of the medicine whose package is on screen in the card.
- `strength`: The strength of the medicine (e.g. "10 mg").
- `where`: The place as typed in the card (a ZIP, a city or an address); used for this one request, never stored.
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `find_nearby_pharmacies` (~451 tokens)

Pharmacy stores within 30 miles, per chain — with the card price when a drug is given.

    Use when the person asks where the pharmacies are near a ZIP or near them.
    ``zip`` is a 5-digit US ZIP (leave it out to use the host's approximate
    location when there is one). ``family`` is a comma-separated list of chain
    codes: walmart, cvs, walgreens, kroger, albertsons, costco, publix, heb,
    hyvee, meijer, wegmans, shoprite, bigy, gianteagle, kinney (``chains`` is the
    older name of the same filter). With ``drug`` (+ optional strength, form,
    quantity) each store carries its chain's card price and observation date.

    Returns stores (chain, address, city, distance, whether it is a pharmacy or a
    store with a pharmacy inside — not verified) and the card. Stock is not
    visible: suggest calling ahead. Coordinates © OpenStreetMap contributors.

Input parameters:

- `chains`: The older name of the family filter: a comma-separated list of pharmacy chain codes to include.
- `drug`: The medicine: a name as typed, or a slug from search_drugs.
- `family`: A comma-separated list of pharmacy chain codes to include: walmart, cvs, walgreens, kroger, albertsons, costco, publix, heb, hyvee, meijer, wegmans, shoprite, bigy, gianteagle, kinney.
- `form`: The dosage form of the medicine (e.g. "tablet").
- `limit` (integer): The maximum number of stores to return per chain (default 3).
- `locale`: A language code for the answer (the host's own is used when left out).
- `quantity`: The quantity to price (the pack size / number of units).
- `strength`: The strength of the medicine (e.g. "10 mg").
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `ui_nearby` (~273 tokens)

Pharmacies near a place for the package on screen — called by the FineRx card itself.

    ``where`` is the place as typed in the card (a ZIP, a city or an address):
    used for this one request, never stored. Not for the model.

Input parameters:

- `family`: A comma-separated list of pharmacy chain codes to include: walmart, cvs, walgreens, kroger, albertsons, costco, publix, heb, hyvee, meijer, wegmans, shoprite, bigy, gianteagle, kinney.
- `form`: The dosage form of the medicine (e.g. "tablet").
- `locale`: A language code for the answer (the host's own is used when left out).
- `quantity`: The quantity to price (the pack size / number of units).
- `slug`: The slug of the medicine whose package is on screen in the card.
- `strength`: The strength of the medicine (e.g. "10 mg").
- `where`: The place as typed in the card (a ZIP, a city or an address); used for this one request, never stored.
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `get_transfer_steps` (~455 tokens)

How to move a prescription from the pharmacy that has it to the one the person wants to use.

    Use when the person says their prescription is at another pharmacy, asks
    how to switch pharmacies, or picked a chain from the card prices and their
    prescription is elsewhere. ``chain`` is the chain they want to move TO, as
    a code: walmart, cvs, walgreens, kroger, albertsons, costco, publix, heb,
    hyvee, meijer, wegmans, shoprite, bigy, gianteagle, kinney. Optional
    ``drug`` (+ strength, form, quantity) adds that chain's card price with its
    date. ``zip`` is a 5-digit US ZIP — pass it only when the person gave one.

    Returns the steps in order (what to say and what to have ready), three
    notes (it is free; no refills left means a new prescription; some medicines
    have stricter rules), the nearest stores of that chain when a place is
    known, and the card. For controlled or age-restricted medicines it returns
    only ``restricted: true``. Not medical advice.

    Next: read the steps out as written; then the card sentence and codes.

Input parameters:

- `chain`: The pharmacy chain to move the prescription TO, as a code: walmart, cvs, walgreens, kroger, albertsons, costco, publix, heb, hyvee, meijer, wegmans, shoprite, bigy, gianteagle, kinney.
- `drug`: The medicine: a name as typed, or a slug from search_drugs.
- `form`: The dosage form of the medicine (e.g. "tablet").
- `locale`: A language code for the answer (the host's own is used when left out).
- `quantity`: The quantity to price (the pack size / number of units).
- `strength`: The strength of the medicine (e.g. "10 mg").
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `compare_basket` (~401 tokens)

Card prices for several medicines at once: which pharmacy chain was seen pricing the whole list, and the sum there.

    Use when the person names two or more medicines and asks what they cost
    together, or which one pharmacy to use for all of them. ``drugs`` is two to
    six names as typed or slugs; a dose and a pack size may ride in each name
    ("atorvastatin 40 mg 90"). ``zip`` is a 5-digit US ZIP — pass it only when
    the person gave one; without it the host's approximate location is used
    when there is one, else the chains are listed nationally.

    Returns the package used for each medicine, then one row per chain: its
    card price for each medicine with the observation date, and — only when
    every medicine was seen with a price there — their sum with the dates the
    prices were observed. When taking each medicine at a different chain comes
    to less than every one-chain sum, that is given too. Names that matched no
    medicine are counted and left out. A sum is an addition of observed card
    prices, never a quote: the pharmacy sets the final price.

    Next: read out the chains with a sum and its dates; then the card sentence
    and codes. One medicine only: use compare_prices.

Input parameters:

- `channel`: An optional channel tag identifying where the request comes through; leave it out unless the calling host supplies one.
- `drugs` (array, required): The medicines to price together: two to six names as typed or slugs (a dose and a pack size may ride in each name).
- `locale`: A language code for the answer (the host's own is used when left out).
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `ui_basket` (~248 tokens)

The same list of medicines for another place — called by the FineRx card itself.

    ``slugs`` with their packages in parallel lists (an empty string or 0 = not
    set). ``where`` is the place as typed in the card: used for this one
    request, never stored. Not for the model.

Input parameters:

- `forms`: Parallel to slugs: the dosage form for each medicine (an empty string means not set).
- `locale`: A language code for the answer (the host's own is used when left out).
- `quantities`: Parallel to slugs: the quantity for each medicine (0 means not set).
- `slugs` (array, required): The medicines' slugs, with their packages in the parallel strengths, forms and quantities lists.
- `strengths`: Parallel to slugs: the strength for each medicine (an empty string means not set).
- `where`: The place as typed in the card (a ZIP, a city or an address); used for this one request, never stored.
- `zip`: A 5-digit US ZIP code to locate prices and stores near; pass it only when the person gave one.

### `open_price_finder` (~228 tokens)

Open the FineRx search inside the card, so the person can look a medicine up themselves.

    Use when the person asks to open FineRx, wants to search or browse on their
    own, or is not sure of the name. Optional ``query`` pre-fills the search
    (a medicine, a brand from another country, a misspelling). The card then
    suggests matches as they type, each with where its card prices start and
    the date, and a pick shows card prices by chain near a place they choose.

    Returns the matches for ``query`` (if any), foreign brands that matched,
    a few often-searched medicines, and the card. What the person picks in the
    card reaches you as context. Hosts without MCP Apps get the matches as text.

Input parameters:

- `locale`: A language code for the answer (the host's own is used when left out).
- `query`: A search to pre-fill in the FineRx search (a medicine, a brand from another country, or a misspelling).

### `ui_suggest` (~99 tokens)

Medicines matching what the person is typing in the FineRx search — called by the card itself.

    Up to eight matches with where their card prices start (dated), and foreign
    brands that matched. Not for the model.

Input parameters:

- `locale`: A language code for the answer (the host's own is used when left out).
- `q` (string, required): What the person is typing in the FineRx search; matching medicines are suggested.

### `get_savings_card` (~263 tokens)

The free FineRx discount card: its codes, how to use it, how to keep it.

    Use when the person asks for the card, how to pay less at the pharmacy, or
    right after you quoted a card price. Optional ``drug`` (a slug from
    search_drugs) adds that drug's card price for its most-priced package, with
    the date it was observed. ``locale`` is a language code (the host's own is
    used when left out).

    Returns the three codes to read at the counter, the steps, the sentence to
    say to the pharmacist, the links to the card page and the printable sheet,
    and the card sentence with the small print. Hosts with MCP Apps show it as an
    interactive card; write the three codes in your answer anyway. The card is
    free, needs no signup and is not insurance.

Input parameters:

- `channel`: An optional channel tag identifying where the request comes through; leave it out unless the calling host supplies one.
- `drug`: The medicine: a name as typed, or a slug from search_drugs.
- `locale`: A language code for the answer (the host's own is used when left out).

### `search_drugs` (~256 tokens)

Find a medicine by name (brand, generic, misspelled or in another script) and get its slug.

    Not needed before compare_prices, compare_basket or get_transfer_steps:
    they take a name as typed. Use it when the person asks what FineRx has, or
    a name is ambiguous.

    Returns candidates with ``slug`` (for get_drug and compare_prices), ``kind``
    (generic/brand) and ``fromCardPrice`` — where its card prices start: the
    amount, the package it is for and the observation date. ``foreignBrands``
    lists home-country brands that matched the same text (Нурофен, No-Spa): when
    ``results`` is empty and ``foreignBrands`` is not, call find_us_equivalent.
    Several candidates: ask which one — brand and generic are different products.

Input parameters:

- `limit` (integer): The maximum number of matching medicines to return (default 10).
- `locale`: A language code for the answer (the host's own is used when left out).
- `query` (string, required): The medicine name to search for (brand, generic, misspelled or in another script).

### `get_drug` (~201 tokens)

Strengths, forms and pack sizes of one medicine that have a card price, and its default package.

    Use when you have a slug and need to know which strengths and quantities
    exist before quoting a price. Returns ``configs`` (strength × form, each
    with quantities, where the card prices for that pack start, with the date,
    and how many chains priced it), ``defaultConfig`` (the package the most chains
    price), ``fromCardPrice``, the card prices of the default package per chain,
    and the card. Next: compare_prices for the package the person takes.

Input parameters:

- `channel`: An optional channel tag identifying where the request comes through; leave it out unless the calling host supplies one.
- `locale`: A language code for the answer (the host's own is used when left out).
- `slug` (string, required): The slug of the medicine to describe, from search_drugs.

### `get_dataset_info` (~102 tokens)

What FineRx covers: pharmacy chains with card prices, how fresh they are, stores on the map, terms.

    Use when the person asks what FineRx is, how big or current the data is, or
    how to cite it. Returns the pharmacy chain families we hold card prices for,
    their store banners, the newest observation date, how many stores we can
    place on a map, the catalog size, and the attribution terms.

### `get_prescription_options` (~218 tokens)

Routes to filling a prescription, including having none yet.

    Use when the person says they have no prescription, asks how to get one, or
    says the brand costs too much. Optional ``drug`` is a slug from
    search_drugs (a name works too). Returns three sections — havePrescription
    (steps), noPrescription (clinics and telehealth, each with the disclosure
    to read out when FineRx earns anything), brandCostly — plus a Medicaid
    note, where the drug's card prices start (dated), and the card. For
    controlled or age-restricted medicines it returns only ``restricted:
    true``: FineRx shows card prices and the card for them, nothing else. Not
    medical advice: never say what to take or at what dose.

Input parameters:

- `drug`: The medicine: a name as typed, or a slug from search_drugs.
- `locale`: A language code for the answer (the host's own is used when left out).

### `find_us_equivalent` (~445 tokens)

What a medicine from another country is in the US, and its card price here.

    Use when the person names a medicine that is not a US product — a brand from
    home (No-Spa, Nurofen, Dolo-Neurobion, 999 Ganmaoling), a name in another
    script (Но-шпа, 泰诺), or an ingredient the US calls something else
    (paracetamol) — or asks "what is this called in the US?". Optional
    ``country`` picks between brands of the same name sold in different places.

    Returns the reviewed entry: ``usClass`` (``same_inn`` = the same active
    ingredient is sold here, ``rx_alternative`` = it is not and the closest US
    options need a prescription, ``no_equivalent`` = nothing here matches),
    ``guidance`` (ONE vetted sentence, to be quoted word for word),
    ``guidanceDisclaimer``, ``inn``, ``usGeneric``, ``usBrands``, ``rxStatus``,
    ``usDrug`` (slug and the card price from which it was seen, with the date),
    ``otherMatches`` for the same brand name in other countries, and the card.
    ``found`` is false when nothing matched.

    Next: quote ``guidance`` as written, then ``guidanceDisclaimer``. With a
    ``usDrug``, compare_prices for its slug. Do not call the US drug the same
    product or suggest swapping; for ``rx_alternative`` and ``no_equivalent``
    name no substitute — send the person to a pharmacist or a doctor.

Input parameters:

- `brand` (string, required): The brand name of the medicine from another country, as typed.
- `channel`: An optional channel tag identifying where the request comes through; leave it out unless the calling host supplies one.
- `country`: The country the brand is sold in; picks between brands of the same name sold in different places.
- `locale`: A language code for the answer (the host's own is used when left out).

### `find_us_equivalents` (~330 tokens)

What several medicines from another country are in the US — the list a person brought from home.

    Use when the person names two or more medicines that are not US products
    (brands from home, names in another script) and asks what they are here.
    ``brands`` is two to six names as typed; optional ``country`` picks between
    brands of the same name sold in different places. One medicine: use
    find_us_equivalent.

    Returns one entry per medicine found, each exactly as find_us_equivalent
    gives it: ``usClass``, the reviewed ``guidance`` sentence (quote it word for
    word), the US product and where its card prices start ONLY when it has the
    same active ingredient, and the card. Names that matched nothing are
    counted and left out — never guess what they are.

    Next: for each entry quote ``guidance``; name no substitute for
    ``rx_alternative`` and ``no_equivalent``; then offer compare_basket for the
    US products that have the same active ingredient.

Input parameters:

- `brands` (array, required): The brand names of the medicines from another country: two to six names as typed.
- `channel`: An optional channel tag identifying where the request comes through; leave it out unless the calling host supplies one.
- `country`: The country the brand is sold in; picks between brands of the same name sold in different places.
- `locale`: A language code for the answer (the host's own is used when left out).

### `ui_equivalent` (~123 tokens)

One foreign brand the person picked in the FineRx search — called by the card itself.

    The same answer as find_us_equivalent for exactly that brand (its
    ``brandSlug`` from ui_suggest): the reviewed guidance, word for word, and
    the US product only when it has the same active ingredient. Not for the model.

Input parameters:

- `brand_slug` (string, required): The slug of the foreign brand picked in the FineRx search.
- `locale`: A language code for the answer (the host's own is used when left out).

### `foreign_brands_for_drug` (~178 tokens)

What a US drug is called abroad — the reverse of find_us_equivalent.

    Use when the person has the US name and wants the home-country one ("what is
    lisinopril called in Mexico?"). ``slug`` comes from search_drugs. Returns the
    reviewed brands that resolve to this drug: ``brand``, ``brandScript``,
    ``countries``, ``inn`` and ``usClass`` (an ``rx_alternative`` entry is a
    DIFFERENT medicine used for the same complaint — say so if you mention it),
    and the card. Do not present any of these as interchangeable with the US
    drug, and do not tell anyone to buy or import one.

Input parameters:

- `slug` (string, required): The slug of the US medicine, from search_drugs.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/cloudcorprecords-medprice/reneturcios-medprice#diagnostics

## Score history

- 2026-11-05: 66
- 2026-11-04: 66

## Common questions

### What is the io.github.CloudCorpRecords/medprice MCP server?

io.github.CloudCorpRecords/medprice is an MCP server listed in the public MCP registry as io.github.CloudCorpRecords/medprice. Compare US prescription prices by pharmacy, find nearby pharmacies and drug equivalents. This page covers its npm package (@reneturcios/medprice).

### Is the io.github.CloudCorpRecords/medprice MCP server safe to use?

io.github.CloudCorpRecords/medprice scores 66 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.CloudCorpRecords/medprice MCP server expose?

io.github.CloudCorpRecords/medprice exposes 18 tools: compare_prices, ui_prices, find_nearby_pharmacies, ui_nearby, get_transfer_steps, and 13 more. Their descriptions and schemas cost roughly 5,094 tokens of context every time the server is loaded.

### Is the io.github.CloudCorpRecords/medprice MCP server still maintained?

io.github.CloudCorpRecords/medprice is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.CloudCorpRecords/medprice MCP server under?

io.github.CloudCorpRecords/medprice declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@reneturcios/medprice
- Socket report: https://socket.dev/npm/package/@reneturcios/medprice
- Repository: https://github.com/CloudCorpRecords/medprice
- Changelog RSS feed: https://verifymcp.io/servers/cloudcorprecords-medprice/reneturcios-medprice.xml
- Changelog JSON feed: https://verifymcp.io/servers/cloudcorprecords-medprice/reneturcios-medprice.json
- HTML version of this page: https://verifymcp.io/servers/cloudcorprecords-medprice/reneturcios-medprice