I built a page that displays information for date and time.

I created a webpage that displays distances from a city to important locations. The form defaults to the current city based on the IP address. For example, when I go to the page it loads Huntington for Huntington West Virginia as the city. I can change the location to default to a different city with my VPN, which worked successfully when I tested it. I can also change the location by specifying a different city than the default such as New York City, Paris, or Brussels. I'm working on improving the form's design so it shows the city in addition to distances to interesting locations.

CloudPublish[
 FormFunction[{"city" -> <|"Interpreter" -> "City", 
     "Input" :> $GeoLocationCity["Name"]|>}, 
  Dataset[AssociationMap[
     Function[position, 
      UnitConvert[GeoDistance[#city, GeoPosition[position]], 
       "Metric"]], {"NullIsland", "NorthPole", "SouthPole", 
      "NorthGeomagneticPole", "NorthModelDipPole", 
      "SouthGeomagneticPole", "SouthModelDipPole"}], 
    DatasetTheme -> "Detailed"] &, "CloudCDF"], 
 Permissions -> "Public"]

The extra Delayed shouldn't be necessary, if that is necessary to make it work then that is curious.

Is there a way to make a programmatic API with a default that could be executed with for example HTTPRequest in Mathematica that defaults to the API's Geolocation if no parameters are specified and otherwise if a location is specified it uses that instead?

I deploy an API. Someone in another part of the world makes a request to my API. The server uses the requesters IP address to decide which city to compute data for. I know the server has a static IP address but if people from different parts of the world queried the Wolfram Cloud API could it tell where they were?

Your problems getting the VPN IP to be picked up are a separate independent issue -- anything we talk about is going to use the GeoIP database. You can deploy this to check what IP and location is seen by cloud:

CloudDeploy[Delayed[{$RequesterAddress, $GeoLocation, $GeoLocationCountry, $GeoLocationCity}]] 

I asked the forms expert what the right way is to populate the field by default, which is to use the Input specification, like this example:

CloudPublish[
    FormFunction[{"country" -> <|"Interpreter" -> "Country", "Input" :> $GeoLocationCountry["Name"]|>}, 
        {"Country" -> #country, "Population" -> #country["Population"]} &
    ]
]

There should be, and I think there could be both a programmatic way to do it and a UI way. Hannah provided a technique to collect this through a form, taking advantage of the fact that GenerateHTTPResponse can nest the active cloud object expressions like APIFunction and FormFunction within the same rest (in her case, an APIFunction that returns a FormFunction). But I think a programmatic way to do it, probably through a query parameter, is also needed and would have to have support added in to the cloud back end. I've put this on our to-do list of things to add to cloud.

I would also like to option that lets the user override the default city. I'm not sure if an api can have intereaction with a user or if the right function would be FormFunction to ask the user for a city and then give data but it seems like there should be a way to add manually overriding and defaults.

That looks like an error from a pre-release build of 13.2. You can work around it by passing a named object, like CloudObject["myip.api"], as the 2nd argument to CloudDeploy:

CloudDeploy[Delayed[$RequesterAddress], CloudObject["myip.api"]]

You may also be able to fix the problem by calling Needs["UUID`"].

How can I make an API that uses the IP address of the visitor to make a map for example? I have tried changing my IP address with the virtual private network Private Internet Access but it still defaults to Huntington.

Yes, testing these geo-location things is not easy. In the cloud, we set

$GeoLocation

(the lat/long) using a geo-IP lookup, which is given by \$RequesterAddress. Then from the location we infer

$GeoLocationCity

and

$GeoLocationCountry

Using a VPN is the right move for testing this by yourself (if you can recruit friends who are somewhere else, that helps too). You would want to confirm the address that the outside world sees, e.g. you could CloudDeploy[Delayed[$RequesterAddress]] and visit that. It's possible that something is getting cached in the API you deployed, which you could test by calling DeleteObject.

I now have a simple API that lets you enter a city and see basic weather data

CloudDeploy[FormFunction @@ 
  APIFunction[ "location" -> "ComputedLocation", 
   Grid[{{Style["Current Temperature", "Subsubsection"], 
       IconData["AirTemperature", 
        WeatherData[#location, "Temperature"]], 
       QuantityForm[WeatherData[#location, "Temperature"], 
        "Abbreviation"]}, {Style["Current Relative Humidity", 
        "Subsubsection"], 
       IconData["RelativeHumidity", 
        WeatherData[#location, "Humidity"]], 
       QuantityForm[WeatherData[#location, "Humidity"], 
        "Abbreviation"]}, {Style["Current Wind Speed", 
        "Subsubsection"], 
       IconData["WindSpeed", WeatherData[#location, "WindSpeed"]], 
       QuantityForm[WeatherData[#location, "WindSpeed"], 
        "Abbreviation"]}, {Style["Current Wind Direction", 
        "Subsubsection"], 
       IconData["WindDirection", 
        WeatherData[#location, "WindDirection"]], 
       QuantityForm[WeatherData[#location, "WindDirection"], 
        "Abbreviation"]}, {Style["Geographical position", 
        "Subsubsection"], FromDMS[#location], 
       DMSString[#location, "Position"]}, {Style["Current time", 
        "Subsubsection"], 
       DateString[Now, "DateTime"]}, {Style[
        "Geographical xyz position", "Subsubsection"], 
       GeoPositionXYZ[#location]}, {Style[
        "Geographical projected position with Bonne grid projection", 
        "Subsubsection"], 
       First[GeoGridPosition[#location, "Bonne"]]}}, 
     Alignment -> Left] & , "CloudCDF"], "versa"]

Here's a simple APIFunction that demonstrates one way to add a default for the current city:

CloudDeploy[APIFunction[{}, 
  FormFunction[{"location" -> <|"Label" -> "City", 
       "Input" -> 
        Replace[$GeoLocationCity, {e_Entity :> e["Name"], _ :> 
           "Your city here"}] , "Interpreter" -> "City"|>},
    LocalTime[#location] &, 
    AppearanceRules -> <|"Title" -> "Please enter a city"|>
    ] &
  ], CloudObject["getlocation.api"], Permissions -> "Public"]