Perl 6, 31 bytes

{$^a;first {$a**$_~~/$a/},2..*}

Try it online!

R, 69 44 bytes

function(n,i=2){while(!grepl(n,n^i))i=i+1;i}

Anonymous function. Works on large i when n is converted to BigZ (see TIO). Thanks for teaching me something Giuseppe and digEmAll!

Try it online!

Python 2, 42 41 bytes

^{-1 byte thanks to Ørjan Johansen (returning y directely)}

f=lambda x,y=2:y*(`x`in`x**y`)or f(x,y+1)

Try it online!

Explanation/Ungolfed

Recursive function trying from $2,3dots$ until we succeed:

# Start recursion with y=2

def f(x,y=2):

    # If we succeed, we arrived at the desired y

    if `x` in `x**y`:

        return y

    # Else we try with next y

    else:

        return f(x, y+1)

Try it online!

JavaScript (ES6 / Node.js),  41  40 bytes

Saved 1 byte thanks to @Shaggy

Takes input as a Number (works for $n<15$) or a BigInt literal.

n=>(g=x=>`${x*=n}`.match(n)?2:-~g(x))(n)

Try it online!

APL (Dyalog Unicode), 25 23 17 bytes

-2 bytes thanks to @Erik the Outgolfer

-6 bytes thanks to @ngn

thanks to @H.PWiz for making the code not require a custom ⎕pp (print precision)

⊢⍟×⍣(∨/(⍕÷)⍷0⍕⊣)⍨

Try it online!

⊢⍟×⍣(∨/(⍕÷)⍷0⍕⊣)⍨

  ×⍣(          )⍨ generates a geometric progression by repeatedly multiplying the argument

                   by its original value

     ∨/(⍕÷)⍷0⍕⊣   the progression stops when this function, applied between the new and the

                   last old member, returns true

         ÷        the original argument (ratio between two consecutive members)

        ⍕         formatted as a string

           ⍷      occurrences within...

            0⍕    ...the formatted (with 0 digits after the decimal point)...

              ⊣   ...new member

     ∨/           are there any?

⊢⍟                use logarithm to determine what power of ⍵ we reached

Pyth, 9 bytes

f}`Q`^QT2

Try it online!

05AB1E, 7 bytes

∞>.Δm¹å

Try it online!

Explanation:

∞>.Δm¹å  //full program

∞        //push infinite list, stack = [1,2,3...]

 >       //increment, stack is now [2,3,4...]

  .Δ     //find the first item N that satisfies the following

     ¹   //input

      å  //is in

    m    //(implicit) input **  N

SAS, 71 66 bytes

Edit: Removed ;run; at the end, since it's implied by the end of inputs.

data a;input n;e=1;do until(find(cat(n**e),cat(n)));e+1;end;cards;

Input data is entered after the cards; statement, like so:

data a;input n;e=1;do until(find(cat(n**e),cat(n)));e+1;end;cards;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

Generates a dataset a containing the input n and the output e.

Jelly, 7 bytes

2ẇ*¥@1#

Try it online!

Clean, 99 bytes

import StdEnv,Text,Data.Integer

$n=hd[p\p<-[fromInt 2..]|indexOf(""<+n)(""<+prod(repeatn p n))>=0]

Try it online!

If it doesn't need to work for giant huge numbers, then

Clean, 64 bytes

import StdEnv,Text

$n=hd[p\p<-[2..]|indexOf(""<+n)(""<+n^p)>=0]

Try it online!

Brachylog, 8 bytes

;.^s?∧ℕ₂

Try it online!

Explanation

;.^         Input ^ Output…

   s?       …contains the Input as a substring…

     ∧      …and…

      ℕ₂    …the Output is in [2,+∞)

Ruby, 37 bytes

->n,i=2{i+=1until/#{n}/=~"#{n**i}";i}

Try it online!

Japt, 10 bytes

@pX søU}a2

Try it

JavaScript (Node.js), 45 bytes

Test cases taken from @Arnauld's answer

a=>eval("for(i=1n;!(''+a**++i).match(a););i")

Try it online!

Charcoal, 19 bytes

Ｗ∨‹Ｌυ²¬№ＩΠυθ⊞υＩθＩＬυ

Try it online! Link is to verbose version of code. Explanation:

Ｗ∨‹Ｌυ²¬№ＩΠυθ⊞

Repeat until the the list length is at least 2 and its product contains the input...

⊞υＩθ

... cast the input to integer and push it to the list.

ＩＬυ

Cast the length of the list to string and implicitly print it.

Python 3, 63 58 bytes

def f(n,e=2):

	while str(n)not in str(n**e):e+=1

	return e

Try it online!

Python2 would probably be shorter, but I like using 3. Coming up wiht a lambda is difficult, but I'm trying a few things.

MathGolf, 10 bytes

ôkï⌠#k╧▼ï⌠

Try it online!

Explanation

This feels extremely wasteful, having to read the input explicitly twice, having to increment the loop counter twice.

ô            start block of length 6

 k           read integer from input

  ï          index of current loop, or length of last loop

   ⌠         increment twice

    #        pop a, b : push(a**b)

     k       read integer from input

      ╧      pop a, b, a.contains(b)

       ▼     do while false with pop

        ï    index of current loop, or length of last loop

         ⌠   increment twice

Ruby, 41 bytes

f=->n,a=n{(a*=n).to_s=~/#{n}/?2:1+f[n,a]}

Try it online!

C# (.NET Core), 104 89 bytes

a=>{int i=2;while(!(System.Numerics.BigInteger.Pow(a,i)+"").Contains(a+""))i++;return i;}

Try it online!

-1 byte: changed for loop to while (thanks to Skidsdev)
-14 bytes: abused C#'s weird string handling to remove ToString() calls

Need to use C#'s BigInteger library, as the standard numeric C# types (int, double, long, ulong, etc.) fail for some larger numbers (including 12, 15, and 17).

Ungolfed:

a => {

    int i = 2;                                          // initialize i



    while( !(System.Numerics.BigInteger.Pow(a,i) + "")  // n = a^i, convert to string

                                .Contains(a + ""))      // if n doesn't contain a

        i++;                                                // increment i



    return i;

}

Python 2, 47 bytes

i,e=input(),2

while`i`not in`i**e`:e+=1

print e

Try it online!

Inspired by @Gigaflop's solution.

Tcl, 69 81 bytes

proc S n {incr i

while {![regexp $n [expr $n**[incr i]]]} {}

puts $i}

Try it online!

PowerShell(V3+), 67 bytes

function f{param($n)$i=1;do{}until([math]::pow($n,++$i)-match$n)$i}

Java (OpenJDK 8), 84 bytes

Takes input as a String representing the number and outputs an int.

Most of the bytes come from the verbosity of the BigDecimal being needed to process the large numbers.

n->{int i=1;while(!(new java.math.BigDecimal(n).pow(++i)+"").contains(n));return i;}

Try it online!

How it works

This is fairly simple but I'll include the explanation for posterity;

n->{                                    // Lamdba taking a String and returning an int

    int i=1;                            // Initialises the count

    while(!                             // Loops and increments until

        (new java.math.BigDecimal(n)    // Creates a new BigDecimal from the input n

            .pow(++i)+"")               // Raises it to the power of the current count

            .contains(n)                // If that contains the input, end the loop

    );

    return i;                           // Return the count

}

Common Lisp, 78 bytes

(lambda(n)(do((e 2(1+ e)))((search(format()"~d"n)(format()"~d"(expt n e)))e)))

Try it online!

J, 26 bytes

2>:@]^:(0=[+/@E.&":^)^:_~]

Try it online!

NOTE: I've changed the final ] to x: in the TIO, to make the tests pass for larger integers.