**Insulin Syringe and Reconstitution Reference API — JSON, No Key**

> Keyless CORS-open JSON over the insulin syringe scales and reconstitution arithmetic published at dosyne.com. CC BY 4.0, documented field semantics, no dosing data.

Source: https://dosyne.com/api/

[Home](https://dosyne.com/)/Reference API

# The syringe reference and the reconstitution arithmetic, as JSON

Everything this site asserts about insulin syringes and reconstitution arithmetic is
published as machine-readable JSON at `dosyne.com/api/v1/`. No key, no account,
no rate limit, CORS open to any origin, licensed [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) with
attribution. It contains no dosing information, and it never will.

## What is here

Dosyne publishes a narrow, checkable thing: the arithmetic that turns a vial strength and
a volume of diluent into a number you can read off a barrel, and the instrument reference
that arithmetic depends on. Those facts are rendered as prose on the reference pages, run
as JavaScript in the five browser calculators, and served here as JSON. All three come
from one module in the repository, and a build gate fails if the calculators and the
published values disagree — so the page you read, the tool you use and the object you
fetch cannot tell you three different things.

*Public endpoints*

| Endpoint | Returns | Use it for |
| --- | --- | --- |
| [`/api/v1/syringes.json`](https://dosyne.com/api/v1/syringes.json) | 3 calibrations, 3 barrel capacities, 2 diluents | Turning a reading into a volume, or a volume into a reading. |
| [`/api/v1/formulas.json`](https://dosyne.com/api/v1/formulas.json) | 8 formulas, 5 readability thresholds, 5 calculators | Implementing the arithmetic, or checking an implementation against ours. |
| [`/api/v1/library.json`](https://dosyne.com/api/v1/library.json) | Every page, with the query it answers and its markdown twin | Finding the source behind a figure, or a page to cite. |
| [`/api/v1/apps.json`](https://dosyne.com/api/v1/apps.json) | A dated App Store snapshot of peptide and GLP-1 tracking apps | Comparing tracking apps. Published by one of them — see the disclosure in the payload. |
| [`/api/v1/status.json`](https://dosyne.com/api/v1/status.json) | Generation timestamp and row counts | Deciding whether to refetch without pulling the payloads. |
| [`/api/v1/openapi.json`](https://dosyne.com/api/v1/openapi.json) | OpenAPI 3.1 over all of the above | Generating a client. |

There is also a machine index of the whole site at [/llms.txt](https://dosyne.com/llms.txt), the
full text of the primary pages at [/llms-full.txt](https://dosyne.com/llms-full.txt), an RFC 9727
catalogue at [/.well-known/api-catalog](https://dosyne.com/.well-known/api-catalog), an ARD
capability manifest at [/.well-known/ai-catalog.json](https://dosyne.com/.well-known/ai-catalog.json),
four agent skills at [/.well-known/agent-skills/](https://dosyne.com/.well-known/agent-skills/index.json),
and an account of what does and does not need authenticating at [/auth.md](https://dosyne.com/auth.md)
(nothing does). Every page on this site also has a markdown copy: append
`index.md` to any URL, or send `Accept: text/markdown`.

## The one fact the whole API encodes

A syringe unit is a volume defined by the barrel. It is not a quantity of drug, and the
barrel cannot know what it holds. One unit on a U-100 syringe is 0.01 mL of
whatever is in it — insulin, saline, or a reconstituted peptide. One unit on a U-40 syringe
is 0.025 mL. That is the entire difference between the two scales, and it is
the reason a number of units, quoted without the concentration it was calculated at, is not
an answer to anything.

Almost every error this API exists to prevent is a version of forgetting that. A dosage
chart printed in units with no concentration beside it cannot be applied to anyone else's
vial. A calculator that hardcodes 100 is wrong on any other barrel. A conversion applied in
the wrong direction produces a number that looks entirely reasonable. The data is shaped to
make those mistakes hard: `ml_per_unit` and `units_per_ml` are both
present so you never have to remember which way the division goes, every computed field
carries the concentration it assumed, and every payload carries a `boundary`
object saying what the figures are not.

## What implementers get backwards

These are not edge cases. Each one produces a plausible wrong volume rather than an error,
which is exactly why they survive code review.

### The direction of a scale conversion

A coarser scale reads *fewer* marks for the same liquid, not more. 100
units on a U-100 barrel is 1 mL; the same 1 mL on a U-40 barrel is 40 units.
The number 2.5 appears in the literature as the ratio between the
volume of one U-40 mark and one U-100 mark, and it is very easy to reach for it when
converting a reading — in which case the answer comes out 6.25 times
too large. This site shipped exactly that in its own syringe visualiser: the "same volume on
U-40" cell multiplied by 2.5 rather than by 40/100,
so 20 units read as 50 instead of 8. It was corrected in September 2026, and the gate that
would have caught it exists now. Convert through the volume — reading, then millilitres,
then the other reading — and the direction cannot invert.

### Micrograms at the boundary

Vials are labelled in milligrams. Amounts are usually discussed in micrograms. The factor of
a thousand between them is the most common defect in a reconstitution calculator, and it is
silent: a result a thousand times out still renders, still fits the field, and only looks
wrong to someone who already knows the answer. Convert once, at the point where input
enters the system, keep one unit internally, and label every field with the unit it is in.
Every numeric field in this API carries its unit in its name for that reason.

### Concentration is required, and there is no sensible default

There is no conversion from an amount to a syringe reading without a concentration. Not a
difficult one, not an approximate one — it does not exist. An implementation that defaults
the concentration when it is missing has invented a vial. If the caller has not supplied
one, the correct response is to say so, which is what the calculators and the MCP tools
here do.

### A graduation note is prose, not a number

Barrel capacity is fixed by the scale: a 0.3 mL U-100 barrel reaches 30 units, a 0.5 mL one
reaches 50, a 1 mL one reaches 100. The *graduation interval* — how far apart the
printed lines are — is a property of the product and varies between manufacturers, which is
why `graduation_note` is a sentence and not a figure. Do not synthesise a number
from it. The only authority on the line spacing is the device in the reader's hand, and the
correct advice is always to count the spaces between numbered marks rather than assume that
every short line is one unit.

### Readability thresholds are not warnings about the arithmetic

The `readability_thresholds` array describes the cases where the calculation is
correct and the result is still unusable: a volume that will not fit one barrel, a reading
too small to resolve by eye, a reading small enough that a one-mark error is a large
proportional one, a concentration high enough that each mark carries a great deal. They are
not error conditions and they do not mean a number is wrong. They mean a number needs a
sentence beside it. An assistant that returns "0.8 units" without mentioning that no barrel
displays that reading has answered precisely, and unhelpfully.

## Field semantics worth stating

`units_per_ml` and `ml_per_unit` are reciprocals of each other and
both are published deliberately. Multiply a volume by `units_per_ml` to get a
reading; multiply a reading by `ml_per_unit` to get a volume. Storing only one
of them is how a division ends up inverted three functions away from where it was written.

`expression` on a formula is written to be read by a person and evaluated by a
machine, with every symbol defined in the accompanying `variables` object and
the unit of the result in `returns`. `worked` is one example carried
from input to output. If your implementation disagrees with `worked`, your
implementation is wrong — that is the field's entire purpose, and it is worth wiring into a
test rather than reading once.

`source` on every row is the page where the same claim is stated in prose with
the reasoning behind it. It is the URL to cite. Nothing in this API is asserted that is not
also asserted on a page a reader can check, which is the only way to guarantee the two
cannot drift apart.

`snapshot_date` on the app comparison is doing real work. Those figures are
public App Store listing data taken on one day; ratings, versions and prices move
afterwards, and the payload carries the date so a consumer can decide whether the snapshot
is still worth quoting. The same payload carries a `disclosure` field, because
the comparison is published by one of the apps in it.

## What this API does not contain

Dosyne publishes arithmetic, not protocols. There is no endpoint here that returns an
amount anyone should take, and there will not be one — not because the data would be hard
to assemble, but because assembling it is the thing this publication exists to refuse. A
JSON file of "typical peptide doses" would be the most requested object on this domain and
the most harmful one to publish, since it would be applied by people with a different vial,
a different concentration and no prescriber, and it would look authoritative while doing it.

- What compound anyone should use.
- What amount anyone should take, how often, or for how long.
- Whether a plan someone describes is safe, correct or advisable.
- Where to buy anything. This site names no vendor and links to none.

What the API does answer is the part with a correct answer:

- Arithmetic: concentration, volume, syringe units, how many draws a vial holds.
- Instrument reference: what a mark on a given barrel is worth on a given scale.
- Procedure mechanics: what reconstitution does, what a diluent is, how storage affects a solution.

Four caveats travel with every figure, and they are in the `boundary` object of
each payload rather than only in this documentation, because a retrieved JSON object
travels alone exactly as a retrieved paragraph does. They are: that a syringe reading is a
volume and says nothing about what is in the liquid; that the arithmetic cannot verify the
vial's contents, sterility or actual concentration; that most research peptides are not
approved by the FDA or EMA for human use and material sold for research use is not made to
pharmaceutical standards; and that dosing decisions belong to a licensed prescriber.

## A worked request

A 5 mg vial reconstituted with 2 mL of bacteriostatic water, drawn at 250 mcg. Fetch the
scale factor, then do four divisions:

```
curl -s https://dosyne.com/api/v1/syringes.json | jq '.scales[] | select(.id=="U-100")'

# { "id": "U-100", "units_per_ml": 100, "ml_per_unit": 0.01, ... }

concentration = 5 mg / 2 mL = 2.5 mg/mL
volume = 0.25 mg / 2.5 mg/mL = 0.1 mL
reading = 0.1 mL * 100 = 10 units
per unit = 2.5 mg/mL * 1000 * 0.01 = 25 mcg per mark
draws = 5 mg / 0.25 mg = 20
```

Ten units on a 1 mL barrel with two-unit lines is a comfortable reading; the same amount at
a concentration four times higher would be 2.5 units, which is inside the
proportionally-fragile threshold and is the kind of thing worth saying out loud. That is
what the thresholds are for, and it is why the diluent volume — the one variable anybody
actually chooses — is worth choosing deliberately rather than by habit.

## Caching, stability and fair use

These are static files behind a CDN, served with a one-hour cache header. There is no rate
limit beyond ordinary fair use, and no identity attached to a request. They are regenerated
whenever the site is rebuilt; [status.json](https://dosyne.com/api/v1/status.json) carries a
`generated_at` timestamp and the row counts, so a client can decide whether to
refetch without pulling the payloads themselves.

The `/api/v1/` prefix is a commitment. Fields will be added; existing fields will
not change meaning or disappear inside v1, and a breaking change would appear at a new
prefix. The syringe reference is a description of physical instruments and is not expected
to change at all.

## Tools, not just files

The same arithmetic is available as an MCP server at `https://dosyne.com/mcp`
(Streamable HTTP, no authentication), described by
[its server card](https://dosyne.com/.well-known/mcp/server-card.json). It exposes six read-only
tools: reconstitute a vial, convert an amount to a reading, work out a diluent volume, look
up a scale, lay out a titration schedule that was given to someone, and search the
reference library. Each one returns the concentration it assumed and the page to cite
alongside the figure. There is an A2A endpoint at `/a2a` over the same lookups,
and the pages themselves register WebMCP tools for an assistant driving the browser.

None of them can write anything, spend anything or read anything about a user. The Dosyne
app keeps its log on the device with no account and no server, so there is no user data
anywhere for an agent to reach — which is also why there is nothing here to authenticate.

## Reuse and attribution

Everything under `/api/v1/` is licensed CC BY 4.0. Reuse it, including
commercially, with a link back to [dosyne.com](https://dosyne.com/) or to the specific
page a figure came from. If you build something on it we would like to know:
[support@dosyne.com](mailto:support@dosyne.com). If you find a value here that
disagrees with a page, that is a defect and we want the report — the two are generated from
one source precisely so that cannot happen quietly.

[Get the app](https://dosyne.com/get/) Free · no account · nothing leaves your phone

---

HTML version: https://dosyne.com/api/
Structured data for this site: https://dosyne.com/api/v1/openapi.json · https://dosyne.com/llms.txt
Dosyne publishes arithmetic, not protocols: nothing here is a dose recommendation,
and dosing decisions belong to a licensed prescriber.
Free to quote and reuse with a link back to the source URL above (CC BY 4.0).