This is pretty good. I only have a few small nitpicks

• Return directly

  You do this a few times:

   if ship['passengers'] != "unknown" and int(ship['passengers']) >= num:
      return True
  return False
  

  The above can be rewritten as:

  return ship['passengers'] != "unknown" and int(ship['passengers']) >= num
  

• Superfluous int call

  int(20), here the int call does nothing, 20 is already an integer.

• You can get more out of the request module.

  Python's requests lib is very powerful and has a lot of features you can use.

  It supports adding params for instance, so instead of:

  #specifies api parameters
  url = endpoint + urllib.parse.urlencode({"format": type, "page": page_num})
  #gets info
  json_data = requests.get(url).json()
  

  You could do:

  json_data = requests.get(endpoint, params={"format": "json", "page": page_num}).json()
  

• Remove unused imports

  sys module is not used, I suggest removing it.

In addition to Ludisposed's great suggestions, I'd recommend another kind of approach in the flow of code.

Right now, your call stack becomes main()->print_pilots_and_ships()->print_page()->print_pilots_on()->get_pilot_name(), all of them called within each other. This means that you can only ever get the final result and even that's printing.

It makes code like this difficult to test, maintain and reuse.

Instead, you could first separate functions that print from functions that return.

import requests
import json
import urllib.parse

PASSENGER_THRESHOLD = 20

def fetch_pilot(pilot_url):
    return requests.get(pilot_url).json()

def fetch_ships():
    endpoint = 'https://swapi.co/api/starships/?'

    ships = []
    for page_num in range(1, 10):
        params = urllib.parse.urlencode({'format': 'json', 'page': page_num})
        response = requests.get(endpoint + params).json()
        if 'results' in response:
            ships += response['results']

    return ships

def has_pilot(ship):
    return 'pilots' in ship

def has_enough_capacity(ship, threshold):
    return ship['passengers'] != 'unknown' and int(ship['passengers']) >= threshold

def is_eligible(ship):
    return has_pilot(ship) and has_enough_capacity(ship, PASSENGER_THRESHOLD)

for pilot_url in ship['pilots']:
        pilot = fetch_pilot(pilot_url)
        print(pilot, ship['name'])

if __name__ == '__main__':
    ships = fetch_ships()
    eligible_ships = [ship for ship in ships if is_eligible(ship)]

    for ship in eligible_ships:
        print_pilots(ship)

Here I have done a couple of things: I've called all functions that do API calls fetch_ to indicate that they do some heavier operations. I've followed Ludisposed's examples and made our is_ and has_ functions neater.

I did a minor change here as I save all the ships in a list and then iterate over that list when filtering. Since the amount of ships here is small, I felt comfortable doing that but if the data is big, it's gonna blow up so you can keep the filtering inside the fetch method as well.

Also in fetch_pilot, we fetch the entire model and then extract what we need when we need it. Now it's more reusable whenever in our code we want to retrieve pilot information.

I also renamed has_enough_passenger to has_enough_capacity since we're looking for the passenger capacity, not the amount of passengers.

Last, I refactored PASSENGER_THRESHOLD into a constant just to show that it's an option. Of course, in many scripts like these, it comes as a user input, in which case it's not really meaningful extraction.