The MathJSON format is a lightweight data interchange format for mathematical notation.
Math  MathJSON 

\[\frac{n}{1+n}\]  ["Divide", "n", ["Add", 1, "n"]] 
\[e^{\imaginaryI \pi }+1=0\]  ["Equal", ["Add", ["Exp", ["Multiply", "Pi", "ImaginaryUnit"], 1]], 0] 
\[\sin^{1}^\prime(x)\]  [["Derivative", 1, ["InverseFunction", "Sin"]], "x"] 
MathJSON is built on the JSON format. Its focus is on interoperability between software programs to facilitate the exchange of mathematical data, as well as the building of scientific software through the integration of software components communicating with a common format.
It is humanreadable, while being easy for machines to generate and parse. It is simple enough that it can be generated, consumed and manipulated using any programming languages.
MathJSON can be transformed from (parsing) and to (serialization) other formats, using a syntax specific to those formats.
The MathJSON library provides an implementation in Javascript/Typescript of utilities that parse LaTeX to MathJSON, serialize MathJSON to LaTeX, and provide a collection of functions for symbolic manipulation and numerical evaluations of MathJSON expressions.
Mathematical notation is used in a broad array of fields, from elementary school arithmetic, engineering, applied mathematics to physics and more. New notations are invented regularly and need to be represented. To address those needs MathJSON is flexible, extensible and customizable. Extensible dictionaries can be used to define new syntax and new semantic.
MathJSON is not intended to be suitable as a visual representation of arbitrary mathematical notations, and as such is not a replacement for LaTeX or MathML.
Structure of a MathJSON Expression
A MathJSON expression is a combination of numbers, strings, symbols, functions and dictionaries.
Number
3.14
314e2
{"num": "3.14"}
{"num": "Infinity"}
Symbol
"x"
"Pi"
{"sym": "Pi", "wikidata": "Q167" }
String
"'Diameter of a circle'"
{"str": "Radius" }
Function
["Add", 1, "x"]
{"fn": [{sym: "Add"}, {num: "1"}, {sym: "x"}]}
Dictionary
{
"dict": {
"hello": 3,
"world": ["Add", 5, 7]
}
}
Numbers, symbols, strings and functions can be expressed either
as an object literal with a "num"
, "str"
, "sym"
or "fn"
key,
respectively, or as a shorthand notation using a JSON number, string or array.
The shorthand notation is more concise and easier to read, but cannot include metadata properties.
Numbers
A MathJSON number is either:
 an object literal with a
"num"
key  a JSON number
Numbers as Object Literals
Numbers can be represented as an object literal with a "num"
key. The
value of the key is a string representation of the number.
{
"num": string
}
The string representing a number follows the JSON syntax for number.
The values NaN
, +Infinity
and Infinity
are used to represented an
undefined results, as per IEEE 754,
positive infinity and negative infinity, respectively.
When a number is outside the bounds of a JSON number (i.e. a 64bit floating
point representation), it is represented by a string of digits 0
…9
,
decimal point .
, plus +
and minus 
sign and exponent sign e
, followed
by a letter:
n
to indicate the number is a large integer (typeBigInt
in JavaScript)d
to indicate the number is an arbitrary precision floating point number (decimal).
JSON numbers
When a number has no extra metadata and is compatible with the JSON representation of numbers, a JSON number can be used.
Specifically:
 the number has to be in the range \([(2^{53})+1, (2^{53})1]\) to fit in a 64bit float (IEEE 7542008, 52bit, about 15 digits of precision).
 the number has to be finite: it cannot be
Infinity
,Infinity
orNaN
.
Examples
0
234.534e46
{ "num": "234.534e46" }
{
"num":
"3.141592653589793238462643383279502884197169399375105d"
}
{ "num": "Infinity" }
Strings
A MathJSON string is either
 an object literal with a
"str"
key  a JSON string that starts and
ends with U+0027 APOSTROPHE
'
.
Strings can contain any character represented by a Unicode scalar value (in the [0…0x10FFFF] range, except for [0xD800…0xDFFF]), but the following characters must be escaped as indicated:
U+0000 to U+001F  \u0000 to \u001f 

U+0008  BACKSPACE  \b or \u0008 
U+0009  TAB  \t or \u0009 
U+000A  LINE FEED  \n or \u000a 
U+000C  FORM FEED  \f or \u000c 
U+000D  CARRIAGE RETURN  \r or \u000d 
U+005C  REVERSE SOLIDUS (backslash)  \\ or \u005c 
U+0022  QUOTATION MARK  \" or \u0022 
The encoding of the string follows the encoding of the JSON payload: UTF8, UTF16LE, UTF16BE, etc…
"'Hello world'"
Symbols
A MathJSON symbol is either:
 an object literal with a
"sym"
key  a JSON string
Symbols are identifiers that represent the name of constants, variables and functions.
Symbols are strings of valid Unicode characters, except:
U+0000 to U+0020  
U+0022  DOUBLE QUOTE  " 
U+005C  REVERSE SOLIDUS  \ 
U+0060  GRAVE ACCENT backtick  `  
U+FFFE  
U+FFFF 
In addition, the first character of a symbol should not be:
U+0021  EXCLAMATION MARK  ! 
U+0022  QUOTATION MARK  " 
U+0021  EXCLAMATION MARK  ! 
U+0022  QUOTATION MARK  " 
U+0023  NUMBER SIGN  # 
U+0024  DOLLAR SIGN  $ 
U+0025  PERCENT  % 
U+0026  AMPERSAND  & 
U+0027  APOSTROPHE  ' 
U+0028  LEFT PARENTHESIS  ( 
U+0029  RIGHT PARENTHESIS  ) 
U+002E  FULL STOP  ' 
U+003A  COLON  : 
U+003C  LESS THAN SIGN  : 
U+003F  QUESTION MARK  ? 
U+0040  COMMERCIAL AT  @ 
U+005B  LEFT SQUARE BRACKET  [ 
U+005D  RIGHT SQUARE BRACKET  ] 
U+005E  CIRCUMFLEX ACCENT  ^ 
U+007B  LEFT CURLY BRACKET  { 
U+007D  RIGHT CURLY BRACKET  } 
U+007E  TILDE  ~ 
Before they are used, symbols are normalized to the Unicode Normalization Form C (NFC). They must be stored internally and compared using the NFC.
JSON escape sequences are applied before Unicode normalization.
These four strings represent the same symbol:
"Å"
"A\u030a"
"\u00c5"
LATIN CAPITAL LETTER A WITH RING ABOVEÅ
and"\u0041\u030a"
LATIN CAPITAL LETTER A + COMBINING RING ABOVEA
+̊
The following naming convention are recommended.
Patterns
Symbols that begin with U+005F LOW LINE _
(underscore) are reserved to
denote wildcards and other placeholders.
Variables

The first character of a variable should be a lowercase or uppercase letter (
a
z
orA
Z
) 
Subsequent characters should be a letter, digit (
0
9
) or underscore (_
).So for example use,
Gamma
rather thanɣ
andTotal
rather than U+2211 NARY SUMMATION∑
, which looks like U+03A3 GREEK CAPITAL LETTER SIGMAΣ
. This visual ambiguity of some Unicode symbols frequently used in math is why we recommend a more restricted character set. 
If a variable is made of several words, use camelCase, i.e.
newDeterminant

Prefer clarity over brevity and avoid obscure abbreviations.
Use
newDeterminant
rather thannewDet
ornDet

The following variables are usually real numbers:
x
,y
,t

The following variables are usually integers:
i
,n
,p
,q

The following variables are usually complex numbers:
z
,w

The following variables are usually lists:
xs
,ys
,ns
Constants
 The first character of a constant should be an uppercase letter
A
Z
 Subsequent characters should be a letter, digit
0
9
or underscore_
.  If a constant is made up of several words, use camelCase, e.g.
SpeedOfLight
Functions
A MathJSON function is either:
 an object literal with a
"fn"
key.  a JSON array
Functions as Object Literal
The default representation of functions is as an object literal with a
"fn"
key. The value of the key is an array representing the function head and
its arguments.
{
"fn": Expression[]
}
The head of the function is the first element in the array. Its presence is required. It indicates the ‘function name’ or ‘what’ the function is about.
The head is frequently is a string, but it can also be another expression.
Following the head are zero or more arguments, which are expressions as well. The arguments form the tail of the function.
The expression corresponding to \(\sin^{1}(x)\) is
[["InverseFunction", "Sin"], "x"]
The head of this expression is ["InverseFunction", "Sin"]
, and the argument is
"x"
.
JSON array
If a function has no extra metadata it can be represented as a JSON array.
For example these two expressions are equivalent:
{ "fn": ["Cos", ["Add", "x", 1]] }
["Cos", ["Add", "x", 1]]
Dictionary
A dictionary is a collection of keyvalue pairs. In some progamming languages it is called a map or associative array.
The keys are strings and the values are MathJSON expressions.
A dictionary is represented as an object literal with a "dict"
key. The
value of the key is a JSON object literal holding the content of the dictionary.
{
"dict": {
"first": 1,
"second": 2,
"third": ["Add", 1, 2]
}
}
Metadata
MathJSON object literals can be annotated with supplemental information.
A number represented as a JSON number, a symbol represented as a JSON string, or a function represented as a JSON array must be transformed into the equivalent object literal before being annotated.
The following metadata keys are recommended:
Key  Note 

wikidata 
A short string indicating an entry in a wikibase. This information can be used to disambiguate the meaning of a symbol 
comment 
A human readable plain string to annotate an expression, since JSON does not allow comments in its encoding 
documentation 
A Markdownencoded string providing documentation about this expression. 
latex 
A visual representation in LaTeX of the expression. This can be useful to preserve nonsemantic details, for example parentheses in an expression or styling attributes 
sourceUrl 
A URL to the source of this expression 
sourceContent 
The source from which this expression was generated. It could be a LaTeX expression, or some other source language. 
sourceOffsets 
A pair of character offsets in sourceContent or sourceUrl from which this expression was produced 
hash 
A string representing a digest of this expression. 
// The ratio of the circumference of a circle to its diameter
{
"sym": "Pi",
"wikidata": "Q167",
"latex": "\\pi"
}
// The greek letter ∏
{
"sym": "Pi",
"wikidata": "Q168",
"comment": "The greek letter π"
}