There are more design dimensions. Being pedantic (& opinionated):
- Consistent: similar operations appear similar across interfaces
- Usable: API solves majority of user problems with little added boilerplate
- Simple: operations express single intent (likely they can be usefully reassembled by client)
- Encapsulated: API exposes minimal interface (maximizing what implementation can change without breaking callers)
The design choice should depend on how your API interacts with the rest of the system, "level" (low/high) of your API, how well defined the problem is, etc.
If you're designing something that looks very much like existing API's--especially system API's--consistency is probably more important than usability. As others have said, usability could be layered on top as a separate API. That higher-level API should probably be designed for usability.
Low-level APIs should focus on simplicity since they will potentially be used by lots of higher level APIs. Being able to combine the calls in different ways is important.
Encapsulation is especially important if the problem isn't well explored. Exposing a lot of an experimental interface is asking to have lots of broken client code (or having to maintain legacy code) if you have to change the design. In this case it can make sense to ignore simplicity/consistency and instead only expose as few functions as possible.