References are not pointers, they CAN be implemented using a memory pointer (into raw memory) or as an offset into a base memory block, and they can also be reference counted or not. References are in general much SAFER than pointers, as they can actually check if the thing they are referencing still exists.
Pointers are just a number, with no guarantees that that number refers to memory which is even still allocated to the process.
Pointers can be incremented while references cannot.
When you de-reference a pointer, the memory there may have been corrupted by another part of your process, while references (assuming you are only using references in most languages all bets are off with unsafe access in rust for example) have the guarantee that the memory you are accessing is not corrupt.
Since pointers are just a number, they are faster to use cause you don't need to do any extra checks at runtime to ensure they are valid.
Java for example has multiple types of References (normal 'Hard' references, soft, weak and phantom). C++ has 'smart pointers' which are a weaker version of references and I think that the many half-way implementation of references that are really just pointers with weak guarantees of safety have muddled the definition. Same goes for objC style ARC references, they are a very good implementation of a pointer with reference features but even Apple changed that when they moved to swift, even if the main way to interact with them (Reference Counting) is the same.
While at the core concept, they both refer to memory, they are very different. References simply have more features everywhere they are implemented (Java, JavaScript, Go, C#, etc.)