if your chartjs version above 2.8 you can easily use precision: 0

study the below example

      responsive: true,
      maintainaspectratio: false,
      title: {
        display: true,
        position: 'top',
        text: 'monthly establish documents value',
        fontsize: 25
      },
      scales: {
        xaxes: [
          {
            stacked: true,
            scalelabel: {
              display: true,
              labelstring: 'months'
            }
          }
        ],

        yaxes: [
          {
            stacked: true,
            beginatzero: true,
            id: 'a',
            scalelabel: {
              display: true,
              labelstring: '$aud'
            }
          },
          {
            stacked: false,
            beginatzero: true,
            id: 'b',
            gridlines: {
              display: false
            },
            scalelabel: {
              display: true,
              labelstring: '#clients '
            },
            position: 'right',
            ticks: {
              min: 0,
              precision: 0
            }
          }
        ]
      }
    } ```

chart.js v3 (2022+)

the most reliable way with chart.js v3 is not to use ticks.precision, but instead provide your own formatter with ticks.callback.

example on how to format y axis labels:

scales: {
  y: {
    ticks: {
      callback: (yvalue) => {
        return math.floor(yvalue); // format to your liking
      },
    },
  },
}

documentation: https://www.chartjs.org/docs/latest/samples/scale-options/ticks.html

you can yaxis optopn;

decimalsinfloat: number

number of fractions to display when there are floating values in y-axis. note: if you have defined a custom formatter function in yaxis.labels.formatter, this won’t have any effect.

i use this:

yaxes: [
        {
            ticks: {
                    callback: function(val) {
                    return number.isinteger(val) ? val : null;
                }
            }
        }
    ]

note: use the callback function for better granular control. we check if val is an integer instead of a floating-point decimal. if it is, we return the value. if not, we return null.

the easiest and most straight forward solution is to add these configurations to your options object:

    scales: {
  yaxes: [
    {
      ticks: {
        precision: 0,
        beginatzero: true,
      },
    },
  ],
},

and define the axes (in my case it is the yaxes) depending on your axes with fractions

you can adding stepsize and beginatzero option like this:

scales: {
  yaxes: [{
    ticks: {
      stepsize: 1,
      beginatzero: true,
    },
  }],
},

another alternative is to use the fixedstepsize option as follows:

options = {
    scales: {
        yaxes: [{
            ticks: {
                fixedstepsize: 1
            }
        }],
    },
};

2019 update

this can now easily be achieved using the precision option:

ticks: {
  precision:0
}

as per the documentation.

if defined and stepsize is not specified, the step size will be rounded to this many decimal places.

example

options: {
  scale: {
    ticks: {
      precision: 0
    }
  }
}

or (single axis)

options: {
  scales: {
    xaxes: [{
      ticks: {
        precision: 0
      }
    }]
  }
}