Python 2, 50 48 bytes

f=lambda s:s==''or len(s)*f(s[1:])/s.count(s[0])

Try it online!

No boring built-ins! To my surprise, this is even shorter than the brute force approach, calculating all of the permutations with itertools and taking the length.

This function uses the formula

$text{# of unique permutations} = frac{text{(# of elements)!}}{prod_{text{unique elements}}{text{(# of occurences of that element)!}}}$

and computes it on the fly. The factorial in the numerator is calculated by multiplying by len(s) in each function call. The denominator is a bit more subtle; in each call, we divide by the number of occurences of that element in what's left of the string, ensuring that for every character c, all numbers between 1 and the amount of occurences of c (inclusive) will be divided by exactly once. Since we divide only at the very end, we're guaranteed not to have any problems with Python 2's default floor division.

Jelly, 4 bytes

Œ!QL

Try it online!

Simply does what was asked: find permutations of input, uniquify and print the length.

Japt, 5 bytes

á â l

Try it online!

R, 69 bytes

function(s,`!`=factorial)(!nchar(s))/prod(!table(el(strsplit(s,""))))

Try it online!

Computes the multinomial coefficient directly.

R, 72 bytes

function(s,x=table(el(strsplit(s,""))))dmultinom(x,,!!x)*sum(1|x)^sum(x)

Try it online!

Uses the multinomial distribution function provided by dmultinom to extract the multinomial coefficient.

Note that the usual (golfier) x<-table(el(strsplit(s,""))) doesn't work inside the dmultinom call for an unknown reason.

Python 2, 57 bytes

lambda s:len(set(permutations(s)))

from itertools import*

Try it online!

Self-documenting: Return the length of the set of unique permutations of the input string.

Python 3, 55 bytes

Credit goes to ArBo on this one:

lambda s:len({*permutations(s)})

from itertools import*

Try it online!

Pyth, 5 bytes

l.{.p

Try it online!

This assumes the input is a python string literal. If input must be raw text, this 6-byte version will work:

l.{.pz

Either way, it just computes all permutations of the input, converts them to a set and gets the number of elements in that set, and implicitly prints that number.

CJam, 4 bytes

le!,

Try it online!

Explanation

Read line as a string (l), unique permutations as an array of strings (e!), length (,), implicit display.

05AB1E, 3 bytes

œÙg

Try it online!

Explanation

  g  # length of the list

 Ù   # of unique

œ    # permutations

     # of the input

MATL, 9 bytes

jY@XuZy1)

Try it online!

Explanation:

j input as string

Y@ get permutations

Xu unique members

Zy size matrix

1) first member of size matrix

Octave / MATLAB, 35 bytes

@(s)size(unique(perms(s),'rows'),1)

Anonymous function that takes a character vector and produces a number.

In MATLAB this can be shortened to size(unique(perms(s),'ro'),1) (33 bytes).

Try it online!

Explanation

@(s)                                  % Anonymous function with input s

                perms(s)              % Permutations. Gives a char matrix

         unique(        ,'rows')      % Deduplicate rows

    size(                       ,1)   % Number of rows

APL (Dyalog Unicode), 24 bytes

⎕CY'dfns'

{≢∪↓⍵[pmat≢⍵]}

Try it online!

Simple Dfn, takes a string as argument.

How:

⎕CY'dfns'      ⍝ Copies the 'dfns' namespace.

{≢∪↓⍵[pmat≢⍵]} ⍝ Main function

          ≢⍵   ⍝ Number of elements in the argument (⍵)

      pmat     ⍝ Permutation Matrix of the range [1..≢⍵]

    ⍵[      ]  ⍝ Index the argument with that matrix, which generates all permutations of ⍵

   ↓           ⍝ Convert the matrix into a vector of strings

  ∪            ⍝ Keep only the unique elements

 ≢             ⍝ Tally the number of elements

APL (Dyalog Unicode), 14 bytes

!∘⍴÷⊂×.(!∘⍴∩)∪

Try it online!

Returns the result as a singleton.

Retina 0.8.2, 73 bytes

(.)(?=(.*?1)*)

/1$#2$*1x1$.'$*

^

1

+`1(?=1*/(1+)x(1)+$)|/1+x1+$

$#2$*

1

Try it online! Uses @ArBo's formula, but evaluates from right-to-left as this can be done in integer arithmetic while still minimising the size of the unary values involved. Explanation:

(.)(?=(.*?1)*)

/1$#2$*1x1$.'$*

For each character, count how many remaining duplicates there are and how many further characters there are, add one to each to take the current character into account, and separate the values so we know which ones are to be divided and which are to be multiplied.

^

1

Prefix a 1 to produce a complete expression.

+`1(?=1*/(1+)x(1)+$)|/1+x1+$

$#2$*

Repeatedly multiply the last and third last numbers while dividing by the second last number. This replaces the last three numbers.

1

Convert to decimal.