DRY

This repetitive code is an anti-pattern:

blueTotal = 0
greenTotal = 0
redTotal = 0
yellowTotal = 0

Please define

houses = 'blue green red yellow'.split()

and then you can use array access to perform "the same action" across all houses:

for house in houses:
    total[house] = 0

One could also assign total = collections.defaultdict(int), but that would be a horse of a different color. (https://docs.python.org/3/library/collections.html#collections.defaultdict)

global

The global keyword is usually not your friend, it leads to unfortunate coupling. Here, it is offering you a hint that you want to define a class, set totals to zero in the __init__() constructor, and then have places() access self.total[].

arg passing

This is a bit crazy:

    for competitors in competitorDetails:
        points()

Yes, you can treat competitors as an implicit argument by making it global, but there is absolutely no reason to, and the current code makes it extremely difficult for readers to understand what is going on. Please, please make competitors an explicit argument, passing it in with points(competitors).

formatting

Clearly this works:

print("blueTotal " + str(blueTotal))

but the explicit call to str is slightly verbose. Consider re-phrasing such print statements in one of these ways:

print("blueTotal", blueTotal)
print(f'blueTotal {blueTotal}')

Here are some hints on how to decrease the size of your code and make it more Pythonic.

Stack Ifs

Anytime you see stacked ifs, that are all basically the same, you should consider using a dict. In the case here, the primary thing the ifs were doing was mapping a race place to points. So let's do that explicitly like:

pointvalues = {        
    0: 15,
    1: 12,
    2: 10,
    3: 8,
    4: 7,
    5: 6,
    6: 5,
    7: 4,
    8: 3,
    9: 2,
    10: 1,
}

Use a dict for tracking like things

Instead of the specially named globals variables for tracking points, you can use a dict, and use your house names as keys to the dict like:

# House Totals
totals = dict(
    blueTotal=0,
    greenTotal=0,
    redTotal=0,
    yellowTotal=0,
)

Or you might use setdefault to save having to init the houses names at all.

Use enumerate:

Instead of explicitly counting loop iterations, you should use the builtin enumerate like:

for place, competitors in enumerate(competitorDetails):
    # Add points to houses
    totals[competitors['house']] += pointvalues.get(place, 0)

Also the above shows how to use the two dict's we built earlier.

A few things no one has touched on yet...

points()

Your points values follow a pattern which can be easily modeled mathematically:

# Assign points from 1st = 15 through to 10-Last being 1
def points():
    global pointvalue
    if count == 0:
        point_value = 15
        places()
    elif count < 3:
        point_value = 14 - 2 * count
        places()
    elif count < 11:
        point_value = 11 - count
        places()
    elif count > 10:
        point_value = 1
        places()

On my machine, this improvement made this section of the program about 2x faster.

if-elif

Since competitors['house'] can only have one value, there is no sense in checking if it is all values with repetitive if statements. Instead, use an if-elif structure or perhaps if-elif-elif-else.

# add points to houses
def places():
    global blue_total, green_total, red_total, yellow_total, point_value
    if competitors['house'] == "blue_total":
        blue_total += point_value
    elif competitors['house'] == "red_total":
        red_total += point_value
    elif competitors['house'] == "yellow_total":
        yellow_total += point_value
    elif competitors['house'] == "green_total":
        green_total += point_value

Style:

Python's own style guide dictates a convention for function and variable names: names should be lowercase, with words separated by underscores as necessary to improve readability.

Therefore: blueTotal -> blue_total and pointvalue -> point_value.