for (int j = 0; j < n; j++)
    {
        for (int i = 0; i < n; i++)
        {
            print_row(n - i - 1, i + 1);
        }
    }

What the code is doing:

• print_row() prints one single row.
• The inner loop prints n rows. Or generates one pyramid.
• The outer loop executes n times. So the outer loop is generating n pyramids (as the inner loop generates a single pyramid, n * 1 pyramid is equal to n pyramids ).

That’s how your code is printing the pyramid n times. Because after generating the pyramid once, you repeat the process until you’ve generated n pyramids.

Simply remove the outer loop.

OP: “to get acclimated to how creating functions works“

Other answers have correctly diagnosed the problem as too many loops in main().

Since you are learning, here is a version that destructively decrements counters demonstrating slightly less code (less chance for a bug to hide somewhere.)

// #includes as required

// get_height() as per OP's code

void print_row( int spaces, int bricks ) {
    /* A comment to say, "Have removed this comment; its being only 'noise' */
    while( spaces-- )
        printf( " " ); // putchar( ' ' ); would work as well /* tutorial */

    while( bricks-- )
        printf( "#" );

    printf( "n" );
}

int main( void ) {
    int n = get_height();
    int b = 0;

    while( n )
       print_row( --n, ++b ); // fewer spaces and more bricks each time

    return 0;
}

Each time print_row() is called, it receives a fresh pair of values for its use.

This code still uses the non-descript variable n in main(). A better name could be chosen.

Be wary of using i and j together in code.

Their similar appearance makes tracking down invisible bugs almost impossible at 4AM.
arr[i][j] & arr[j][i] look too similar in a small font or viewed with bleary eyes.
Plus, i and j are so generic they provide little information to a source code reader.

Comments like // Print spaces are considered noise.

Comments should explain why code has been written as it has:

// going left-then-right because right-then-left always fails on Thursdays

Don’t explain the simple stuff. Let your code speak for itself.

x = x + 1; // increment x is excrement

Use comments sparingly and only to explain the “why” of code.

Advanced technique:
Acknowledging that the CS50 challenge is to print rows of spaces (SP) and hashes ('#'), here is a possible replacement for print_row() that almost fulfills the requirements.
(Offered as an example of the power of C’s function printf().)

void print_row( int spaces, int bricks ) {
    printf( "%*c%0*dn", spaces+1, ' ', bricks, 0 );
}

Its output when int n = 5; is used in main():

     0 // <== definitely not a '#'
    00
   000
  0000
 00000

printf() is commonly used to pad its output with leading or trailing SP characters to achieve a desired width.
Not commonly used, printf() is also capable of producing multiple instances of the digit 0. In this example, the value 0 has been printed with increasing numbers of leading 0‘s. To the best of my knowledge, SP and 0 are the only characters that can be coaxed out of printf()‘s capabilities for “padding” output.

This is something quite esoteric to store away, and come back to once you’ve learned much more about C and printf(). Its terseness, and especially its opacity, WOULD justify (require!?) a comment that explains to the casual reader what is going on with that one line of code.

Your code is incomplete, but it seems the problem is here.

    for (int j = 0; j < n; j++)
    {
        for (int i = 0; i < n; i++)
        {
            print_row(n - i - 1, i + 1);
        }
    }

The inner loop prints the rows. The outer loop repeats the process. A giveaway is that j is never used. If n is 3 you’ll get 3 rows repeated 3 times.

Adding printf("i: %d, j: %dn", i, j) to show the value of i and j at each print_row call will be illustrative.

    for (int j = 0; j < n; j++)
    {
        for (int i = 0; i < n; i++)
        {
            printf("i: %d, j: %dn", i, j);
            print_row(n - i - 1, i + 1);
        }
    }

As others have identified the core issues with your loops, it may be instructive to see how we can remove some of these loops.

void print_row(int spaces, int bricks)
{
    // Print spaces
    for (int j = 0; j < spaces; j++)
    {
        printf(" ");
    }
    // Print bricks
    for (int i = 0; i < bricks; i++)
    {
        printf("#");
    }
    printf("n");
}

Let’s use printf to print the spaces for us by including a width field.

void print_row(int spaces, int bricks) {
    printf("%*s", spaces, "");

    for (int i = 0; i < bricks; i++) {
        printf("#");
    }

    printf("n");
}

But apparently the longest line is 8 characters and printf‘s %s specifier can limit the length of a string printed. We only need to be able to print eight bricks.

void print_row(int spaces, int bricks) {
    char *bricks_str = "########";
    int line_len = spaces + bricks;

    printf(
        "%*.*sn", 
        line_len,   // The amount of chars to pad the string to.
        bricks,     // The maximum number of characters to print
                    // from the string.
        bricks_str
    );
}