> ## Documentation Index
> Fetch the complete documentation index at: https://syncupai-robbalian-entrances-docs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Finding Places

> Search and discover places using geographic filters

export const FindPlacesInteractive = () => {
  const {useState, useRef, useEffect, useCallback} = React;
  const mapContainerRef = useRef(null);
  const mapRef = useRef(null);
  const popupRef = useRef(null);
  const mapboxToken = 'pk.eyJ1IjoibGthczUxIiwiYSI6ImNsejkwNXkydDAyMmIyaXBvMGF6d3g1bDMifQ.A7Ey8Qb14RTMNh27c3s_FQ';
  const [apiKey, setApiKey] = useState('');
  const [latitude, setLatitude] = useState(37.7749);
  const [longitude, setLongitude] = useState(-122.4194);
  const [radius, setRadius] = useState(1000);
  const [category, setCategory] = useState('cafe');
  const [isLoading, setIsLoading] = useState(false);
  const [results, setResults] = useState(null);
  const [error, setError] = useState(null);
  useEffect(() => {
    const updateCodeExamples = () => {
      const codeBlocks = document.querySelectorAll('code');
      codeBlocks.forEach(block => {
        const text = block.textContent;
        if (text && text.includes('Authorization: Bearer')) {
          const displayKey = apiKey || '{YOUR_API_KEY}';
          const updated = text.replace(/Bearer\s+[^\s'"]*/g, `Bearer ${displayKey}`);
          if (updated !== text) {
            block.textContent = updated;
          }
        }
      });
    };
    updateCodeExamples();
  }, [apiKey]);
  const createCircleGeoJSON = useCallback((lat, lng, radiusMeters) => {
    const points = 64;
    const distanceX = radiusMeters / (111320 * Math.cos(lat * Math.PI / 180));
    const distanceY = radiusMeters / 110540;
    const coordinates = [];
    for (let i = 0; i <= points; i++) {
      const angle = i / points * 2 * Math.PI;
      const dx = distanceX * Math.cos(angle);
      const dy = distanceY * Math.sin(angle);
      coordinates.push([lng + dx, lat + dy]);
    }
    return {
      type: 'Feature',
      geometry: {
        type: 'Polygon',
        coordinates: [coordinates]
      }
    };
  }, []);
  useEffect(() => {
    const loadMapbox = async () => {
      if (!document.querySelector('link[href*="mapbox-gl.css"]')) {
        const link = document.createElement('link');
        link.rel = 'stylesheet';
        link.href = 'https://api.mapbox.com/mapbox-gl-js/v3.0.0/mapbox-gl.css';
        document.head.appendChild(link);
      }
      if (!window.mapboxgl) {
        const script = document.createElement('script');
        script.src = 'https://api.mapbox.com/mapbox-gl-js/v3.0.0/mapbox-gl.js';
        document.head.appendChild(script);
        await new Promise(resolve => {
          script.onload = resolve;
        });
      }
      const mapboxgl = window.mapboxgl;
      if (!mapContainerRef.current || !mapboxgl || mapRef.current) return;
      mapboxgl.accessToken = mapboxToken;
      const map = new mapboxgl.Map({
        container: mapContainerRef.current,
        style: 'mapbox://styles/mapbox/satellite-streets-v12',
        center: [longitude, latitude],
        zoom: 13
      });
      map.addControl(new mapboxgl.NavigationControl());
      popupRef.current = new mapboxgl.Popup({
        closeButton: false,
        closeOnClick: false
      });
      map.on('load', () => {
        map.addSource('search-center', {
          type: 'geojson',
          data: {
            type: 'Feature',
            geometry: {
              type: 'Point',
              coordinates: [longitude, latitude]
            }
          }
        });
        map.addLayer({
          id: 'search-center',
          type: 'circle',
          source: 'search-center',
          paint: {
            'circle-radius': 10,
            'circle-color': '#3B82F6',
            'circle-stroke-width': 3,
            'circle-stroke-color': '#ffffff'
          }
        });
        map.addSource('search-radius', {
          type: 'geojson',
          data: createCircleGeoJSON(latitude, longitude, radius)
        });
        map.addLayer({
          id: 'search-radius-fill',
          type: 'fill',
          source: 'search-radius',
          paint: {
            'fill-color': '#3B82F6',
            'fill-opacity': 0.1
          }
        });
        map.addLayer({
          id: 'search-radius-line',
          type: 'line',
          source: 'search-radius',
          paint: {
            'line-color': '#2563EB',
            'line-width': 2,
            'line-dasharray': [3, 3]
          }
        });
        map.addSource('place-results', {
          type: 'geojson',
          data: {
            type: 'FeatureCollection',
            features: []
          }
        });
        map.addLayer({
          id: 'place-results',
          type: 'circle',
          source: 'place-results',
          paint: {
            'circle-radius': 8,
            'circle-color': '#10B981',
            'circle-stroke-width': 2,
            'circle-stroke-color': '#ffffff'
          }
        });
        map.addLayer({
          id: 'place-labels',
          type: 'symbol',
          source: 'place-results',
          layout: {
            'text-field': ['get', 'name'],
            'text-variable-anchor': ['top', 'bottom', 'left', 'right'],
            'text-radial-offset': 1,
            'text-size': 11
          },
          paint: {
            'text-color': '#1F2937',
            'text-halo-color': '#ffffff',
            'text-halo-width': 2
          }
        });
        map.on('click', e => {
          const {lng, lat} = e.lngLat;
          setLatitude(lat);
          setLongitude(lng);
          const centerSource = map.getSource('search-center');
          if (centerSource) {
            centerSource.setData({
              type: 'Feature',
              geometry: {
                type: 'Point',
                coordinates: [lng, lat]
              }
            });
          }
          const radiusSource = map.getSource('search-radius');
          if (radiusSource) {
            radiusSource.setData(createCircleGeoJSON(lat, lng, radius));
          }
        });
        map.on('mouseenter', 'place-results', e => {
          map.getCanvas().style.cursor = 'pointer';
          if (e.features && e.features[0] && popupRef.current) {
            const feature = e.features[0];
            const coords = feature.geometry.coordinates;
            const props = feature.properties;
            popupRef.current.setLngLat(coords).setHTML(`
                <div style="padding: 8px; max-width: 250px;">
                  <div style="font-weight: 600; margin-bottom: 4px;">${props.name || 'Unknown'}</div>
                  ${props.full_address ? `<div style="font-size: 12px; color: #666;">${props.full_address}</div>` : ''}
                  ${props.category_primary ? `<div style="font-size: 11px; margin-top: 4px; color: #888;">${props.category_primary}</div>` : ''}
                </div>
              `).addTo(map);
          }
        });
        map.on('mouseleave', 'place-results', () => {
          map.getCanvas().style.cursor = '';
          if (popupRef.current) popupRef.current.remove();
        });
      });
      mapRef.current = map;
    };
    loadMapbox();
    return () => {
      if (mapRef.current) {
        mapRef.current.remove();
        mapRef.current = null;
      }
    };
  }, []);
  useEffect(() => {
    if (!mapRef.current || !mapRef.current.isStyleLoaded()) return;
    const radiusSource = mapRef.current.getSource('search-radius');
    if (radiusSource) {
      radiusSource.setData(createCircleGeoJSON(latitude, longitude, radius));
    }
  }, [latitude, longitude, radius, createCircleGeoJSON]);
  const handleSearch = async () => {
    setIsLoading(true);
    setError(null);
    try {
      const requestBody = {
        location_filter: {
          latitude: latitude,
          longitude: longitude,
          radius: radius
        }
      };
      if (category.trim()) {
        const categories = category.split(',').map(c => c.trim()).filter(c => c);
        if (categories.length > 0) {
          requestBody.categories = categories;
        }
      }
      const headers = {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      };
      const response = await fetch('https://api.reprompt.io/v2/find-places', {
        method: 'POST',
        headers,
        body: JSON.stringify(requestBody)
      });
      if (!response.ok) {
        const errorText = await response.text();
        if (response.status === 401) {
          throw new Error('Invalid API key. Please check your key and try again.');
        }
        throw new Error(`API returned ${response.status}: ${errorText}`);
      }
      const data = await response.json();
      setResults(data);
      if (mapRef.current) {
        const placesSource = mapRef.current.getSource('place-results');
        if (placesSource) {
          const features = (data.results || []).map(place => ({
            type: 'Feature',
            geometry: {
              type: 'Point',
              coordinates: [place.longitude, place.latitude]
            },
            properties: {
              name: place.name,
              full_address: place.full_address,
              category_primary: place.category_primary
            }
          }));
          placesSource.setData({
            type: 'FeatureCollection',
            features
          });
          if (features.length > 0) {
            const bounds = new window.mapboxgl.LngLatBounds();
            features.forEach(f => bounds.extend(f.geometry.coordinates));
            bounds.extend([longitude, latitude]);
            mapRef.current.fitBounds(bounds, {
              padding: 50,
              maxZoom: 15
            });
          }
        }
      }
    } catch (err) {
      setError(err.message || 'Failed to search places');
    } finally {
      setIsLoading(false);
    }
  };
  return <div style={{
    width: '100%',
    marginTop: '20px',
    marginBottom: '20px'
  }}>
      {}
      <div style={{
    marginBottom: '16px',
    display: 'flex',
    gap: '8px',
    alignItems: 'flex-end'
  }}>
        <div style={{
    flex: 1
  }}>
          <label style={{
    display: 'block',
    fontSize: '13px',
    fontWeight: '500',
    marginBottom: '4px'
  }}>
            API Key (required for requests - will inject into examples)
          </label>
          <input type="password" placeholder="Enter your Reprompt API key" value={apiKey} onChange={e => setApiKey(e.target.value)} style={{
    width: '100%',
    padding: '8px 12px',
    borderRadius: '6px',
    border: '1px solid #d1d5db',
    fontSize: '13px',
    fontFamily: 'monospace'
  }} />
        </div>
      </div>

      {}
      <div style={{
    display: 'grid',
    gridTemplateColumns: 'repeat(auto-fit, minmax(200px, 1fr))',
    gap: '12px',
    marginBottom: '16px'
  }}>
        <div>
          <label style={{
    display: 'block',
    fontSize: '13px',
    fontWeight: '500',
    marginBottom: '4px'
  }}>
            Latitude
          </label>
          <input type="number" step="any" value={latitude.toFixed(6)} onChange={e => setLatitude(parseFloat(e.target.value) || 0)} style={{
    width: '100%',
    padding: '8px',
    border: '1px solid #D1D5DB',
    borderRadius: '6px',
    fontSize: '13px'
  }} />
        </div>
        <div>
          <label style={{
    display: 'block',
    fontSize: '13px',
    fontWeight: '500',
    marginBottom: '4px'
  }}>
            Longitude
          </label>
          <input type="number" step="any" value={longitude.toFixed(6)} onChange={e => setLongitude(parseFloat(e.target.value) || 0)} style={{
    width: '100%',
    padding: '8px',
    border: '1px solid #D1D5DB',
    borderRadius: '6px',
    fontSize: '13px'
  }} />
        </div>
        <div>
          <label style={{
    display: 'block',
    fontSize: '13px',
    fontWeight: '500',
    marginBottom: '4px'
  }}>
            Radius (m)
          </label>
          <input type="number" value={radius} onChange={e => setRadius(parseInt(e.target.value) || 1000)} style={{
    width: '100%',
    padding: '8px',
    border: '1px solid #D1D5DB',
    borderRadius: '6px',
    fontSize: '13px'
  }} />
        </div>
        <div>
          <label style={{
    display: 'block',
    fontSize: '13px',
    fontWeight: '500',
    marginBottom: '4px'
  }}>
            Category
          </label>
          <input type="text" value={category} onChange={e => setCategory(e.target.value)} placeholder="e.g., restaurant, cafe" style={{
    width: '100%',
    padding: '8px',
    border: '1px solid #D1D5DB',
    borderRadius: '6px',
    fontSize: '13px'
  }} />
        </div>
      </div>

      {}
      <button onClick={handleSearch} disabled={isLoading || !apiKey || !apiKey.trim()} style={{
    width: '100%',
    padding: '10px',
    backgroundColor: isLoading || !apiKey || !apiKey.trim() ? '#9CA3AF' : '#3B82F6',
    color: 'white',
    border: 'none',
    borderRadius: '6px',
    fontSize: '14px',
    fontWeight: '500',
    cursor: isLoading || !apiKey || !apiKey.trim() ? 'not-allowed' : 'pointer',
    marginBottom: '16px'
  }}>
        {isLoading ? 'Searching...' : 'Find Places'}
      </button>

      {}
      {error && <div style={{
    padding: '12px',
    backgroundColor: '#FEF2F2',
    border: '1px solid #FCA5A5',
    borderRadius: '6px',
    color: '#991B1B',
    fontSize: '13px',
    marginBottom: '16px'
  }}>
          {error}
        </div>}

      {}
      <div style={{
    position: 'relative'
  }}>
        <div ref={mapContainerRef} style={{
    width: '100%',
    height: '500px'
  }} />

        {}
        <div style={{
    position: 'absolute',
    top: '12px',
    left: '12px',
    backgroundColor: 'rgba(255, 255, 255, 0.95)',
    backdropFilter: 'blur(8px)',
    padding: '12px 16px',
    borderRadius: '8px',
    boxShadow: '0 2px 8px rgba(0,0,0,0.15)',
    fontSize: '12px',
    lineHeight: '1.8',
    pointerEvents: 'none'
  }}>
          <div style={{
    fontWeight: '600',
    marginBottom: '6px',
    fontSize: '13px'
  }}>Legend</div>
          <div style={{
    display: 'flex',
    alignItems: 'center',
    gap: '8px',
    marginBottom: '2px'
  }}>
            <div style={{
    width: '12px',
    height: '12px',
    borderRadius: '50%',
    backgroundColor: '#3B82F6',
    border: '2px solid white'
  }} />
            <span>Search Center</span>
          </div>
          <div style={{
    display: 'flex',
    alignItems: 'center',
    gap: '8px',
    marginBottom: '2px'
  }}>
            <div style={{
    width: '12px',
    height: '2px',
    backgroundColor: '#3B82F6',
    opacity: '0.5'
  }} />
            <span>Search Radius</span>
          </div>
          <div style={{
    display: 'flex',
    alignItems: 'center',
    gap: '8px'
  }}>
            <div style={{
    width: '12px',
    height: '12px',
    borderRadius: '50%',
    backgroundColor: '#10B981',
    border: '2px solid white'
  }} />
            <span>Places Found</span>
          </div>
        </div>
      </div>

      {}
      {results && results.results && results.results.length > 0 && <div style={{
    marginTop: '16px'
  }}>
          <Tip>
            Found {results.results.length} {results.results.length === 1 ? 'place' : 'places'} in this area
          </Tip>
        </div>}

      {}
      {results && results.results && results.results.length > 0 && <div style={{
    marginTop: '20px'
  }}>
          <CodeBlock language="json">
            <code>
              {JSON.stringify({
    results: results.results.slice(0, 3)
  }, null, 2)}
            </code>
          </CodeBlock>
        </div>}
    </div>;
};

## Overview

The [`/find-places`](/api-reference/places/find-places) endpoint lets you search for a large number of places over 3 different data sources: Overture, Foursquare and Reprompt.

The most use cases is to find places near a given coordinate with a radius.

## Interactive Demo

**Try it:** Click anywhere on the map to set a search location, adjust the parameters, then click "Find Places"

<FindPlacesInteractive />

## Basic Search

The simplest way to find places is by searching within a radius of a specific coordinate.

### Search by Coordinates and Radius

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST \
    'https://api.reprompt.io/v2/find-places' \
    -H 'Authorization: Bearer {YOUR_API_KEY}' \
    -H 'Content-Type: application/json' \
    -d '{
      "location_filter": {
        "latitude": 37.7749,
        "longitude": -122.4194,
        "radius": 1000
      },
      "categories": ["cafe"]
    }'
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://api.reprompt.io/v2/find-places",
      headers={
          "Authorization": "Bearer {YOUR_API_KEY}",
          "Content-Type": "application/json"
      },
      json={
          "location_filter": {
              "latitude": 37.7749,
              "longitude": -122.4194,
              "radius": 1000
          },
          "categories": ["cafe"]
      }
  )

  places = response.json()
  ```
</CodeGroup>

**Response:**

```json theme={null}
{
  "results": [
    {
      "place_id": "9d7de33e-5d98-57af-9307-02481c03b7ad",
      "name": "Blue Bottle Coffee",
      "full_address": "55 s van ness ave, san francisco, ca 94103",
      "latitude": 37.773909,
      "longitude": -122.418616,
      "category_primary": "coffee_shop",
      "phone": "+1 510-661-3510",
      "website": "https://bluebottlecoffee.com/",
      "operating_status": "Open",
      "distance_m": 129.965146
    }
  ]
}
```

**Key Parameters:**

* `latitude` (required): Latitude coordinate in decimal degrees
* `longitude` (required): Longitude coordinate in decimal degrees
* `radius` (optional): Search radius in meters. Default: 500m, Maximum: 10,000m (10km)
* `categories` (optional): Array of place categories to filter results

### Multiple Categories

Search for multiple types of places simultaneously:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST \
    'https://api.reprompt.io/v2/find-places' \
    -H 'Authorization: Bearer {YOUR_API_KEY}' \
    -H 'Content-Type: application/json' \
    -d '{
      "location_filter": {
        "latitude": 40.7128,
        "longitude": -74.0060,
        "radius": 2000
      },
      "categories": ["restaurant", "cafe", "bar"]
    }'
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://api.reprompt.io/v2/find-places",
      headers={
          "Authorization": "Bearer {YOUR_API_KEY}",
          "Content-Type": "application/json"
      },
      json={
          "location_filter": {
              "latitude": 40.7128,
              "longitude": -74.0060,
              "radius": 2000
          },
          "categories": ["restaurant", "cafe", "bar"]
      }
  )

  places = response.json()
  ```
</CodeGroup>

**Response:**

```json theme={null}
{
  "results": [
    {
      "place_id": "1a2b3c4d-5e6f-7g8h-9i0j-k1l2m3n4o5p6",
      "name": "The Modern",
      "full_address": "9 w 53rd st, new york, ny 10019",
      "category_primary": "restaurant",
      "distance_m": 450.123
    },
    {
      "place_id": "2b3c4d5e-6f7g-8h9i-0j1k-l2m3n4o5p6q7",
      "name": "Stumptown Coffee Roasters",
      "full_address": "18 w 29th st, new york, ny 10001",
      "category_primary": "cafe",
      "distance_m": 678.456
    },
    {
      "place_id": "3c4d5e6f-7g8h-9i0j-1k2l-m3n4o5p6q7r8",
      "name": "The Dead Rabbit",
      "full_address": "30 water st, new york, ny 10004",
      "category_primary": "bar",
      "distance_m": 892.789
    }
  ]
}
```

### Compare Coffee Chain Coverage

Find multiple chains to compare their coverage in an area:

<CodeGroup>
  ```python Python theme={null}
  import requests
  from collections import Counter

  response = requests.post(
      "https://api.reprompt.io/v2/find-places",
      headers={
          "Authorization": "Bearer {YOUR_API_KEY}",
          "Content-Type": "application/json"
      },
      json={
          "location_filter": {
              "latitude": 37.7749,
              "longitude": -122.4194,
              "radius": 3000
          },
          "categories": ["coffee_shop", "cafe"]
      }
  )

  places = response.json()

  # Filter results by chain name
  starbucks = [p for p in places['results'] if 'Starbucks' in p['name']]
  philz = [p for p in places['results'] if 'Philz' in p['name']]

  print(f"Starbucks: {len(starbucks)} locations")
  print(f"Philz Coffee: {len(philz)} locations")
  ```

  ```json Response theme={null}
  {
    "results": [
      {
        "place_id": "97fb55a2-32bc-5147-ac08-44ff7e931c54",
        "name": "Starbucks",
        "full_address": "150 van ness ave, san francisco, ca 94102",
        "latitude": 37.777184,
        "longitude": -122.41942,
        "category_primary": "coffee_shop",
        "category_alternates": ["cafe"],
        "phone": "+1 415-558-7715",
        "website": "https://www.starbucks.com/store-locator/store/1028036",
        "operating_status": "Open",
        "distance_m": 253.975295
      },
      {
        "place_id": "0a5c37c2-7c24-5ce0-86f6-9d30214f70b9",
        "name": "Philz Coffee",
        "full_address": "399 golden gate ave, san francisco, ca 94102",
        "latitude": 37.7813,
        "longitude": -122.416942,
        "category_primary": "coffee_shop",
        "category_alternates": ["cafe"],
        "phone": "+1 415-621-7000",
        "website": "http://www.philzcoffee.com/",
        "operating_status": "Open",
        "distance_m": 743.713544
      }
      // ... 462 more results (35 Starbucks, 11 Philz Coffee)
    ],
    "metadata": {
      "total_results": 464
    }
  }
  ```
</CodeGroup>

## Advanced Search

### Search Entire Cities

Search all places within a city boundary - no need for multiple radius searches.

<CodeGroup>
  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://api.reprompt.io/v2/find-places",
      headers={
          "Authorization": "Bearer {YOUR_API_KEY}",
          "Content-Type": "application/json"
      },
      json={
          "location_filter": {
              "locality": "San Francisco",
              "country_code": "US"
          },
          "categories": ["restaurant"]
      }
  )

  places = response.json()
  print(f"Found {places['metadata']['total_results']} restaurants")
  ```

  ```json Response theme={null}
  {
    "results": [
      {
        "place_id": "8566c58d-73f9-57d6-ac19-9c7b10e48ad0",
        "name": "Sf-mandarin",
        "full_address": "san francisco, ca 94103",
        "latitude": 37.77493,
        "longitude": -122.419416,
        "category_primary": "restaurant",
        "category_alternates": ["restaurant"],
        "website": "http://www.sf-mandarin.com/",
        "operating_status": "Open",
        "distance_m": 3.620144
      },
      {
        "place_id": "dab7d64a-318b-5594-937f-99f8e3d4d723",
        "name": "Mexirean Grill & Resto Br",
        "full_address": "1400 tarusan street, san francisco, ca 94103",
        "latitude": 37.77493,
        "longitude": -122.419416,
        "category_primary": "bar_and_grill_restaurant",
        "category_alternates": [],
        "phone": "+63 951 559 5515",
        "operating_status": "Open",
        "distance_m": 3.620144
      }
      // ... up to 500 results
    ],
    "metadata": {
      "total_results": 500
    }
  }
  ```
</CodeGroup>

<Note>
  Returns first 500 results immediately. For complete datasets with >500 places, results include information about accessing the full dataset.
</Note>

### Search Within Custom Boundaries

Use GeoJSON polygons to search specific neighborhoods or custom areas.

<CodeGroup>
  ```python Python theme={null}
  import requests

  # Mission District boundary (San Francisco postal code 94110)
  mission_boundary = {
      "type": "Polygon",
      "coordinates": [[[-122.405115, 37.764635], [-122.405212, 37.763469], [-122.405832, 37.762199], [-122.406365, 37.761199], [-122.40645, 37.760114], [-122.406167, 37.759315], [-122.40405, 37.757619], [-122.403428, 37.756871], [-122.403328, 37.756082], [-122.40315, 37.754488], [-122.403437, 37.753199], [-122.403364, 37.752366], [-122.405091, 37.745281], [-122.405614, 37.7442], [-122.406652, 37.741241], [-122.407045, 37.739587], [-122.408136, 37.73964], [-122.408009, 37.737734], [-122.408284, 37.736846], [-122.409287, 37.735258], [-122.410052, 37.734675], [-122.411978, 37.733732], [-122.414554, 37.732371], [-122.416255, 37.732034], [-122.419881, 37.732016], [-122.423718, 37.73155], [-122.425944, 37.731698], [-122.422274, 37.732383], [-122.421787, 37.732774], [-122.422472, 37.733967], [-122.422901, 37.734388], [-122.426983, 37.735455], [-122.427849, 37.734718], [-122.428578, 37.735082], [-122.428454, 37.735882], [-122.42551, 37.737774], [-122.42452, 37.739868], [-122.424394, 37.740405], [-122.424168, 37.740805], [-122.426453, 37.764634], [-122.421885, 37.764908], [-122.42173, 37.763304], [-122.421248, 37.764947], [-122.407553, 37.765798], [-122.407431, 37.764497], [-122.405115, 37.764635]]]
  }

  response = requests.post(
      "https://api.reprompt.io/v2/find-places",
      headers={
          "Authorization": "Bearer {YOUR_API_KEY}",
          "Content-Type": "application/json"
      },
      json={
          "location_filter": {"geometry": mission_boundary},
          "categories": ["restaurant"]
      }
  )

  places = response.json()
  print(f"Found {len(places['results'])} restaurants in Mission District")
  ```

  ```json Response theme={null}
  {
    "results": [
      {
        "place_id": "mission001",
        "name": "La Taqueria",
        "full_address": "2889 Mission St, San Francisco, CA 94110",
        "latitude": 37.7516,
        "longitude": -122.4181,
        "category_primary": "restaurant",
        "phone": "+1 415-285-7117",
        "operating_status": "Open"
      },
      {
        "place_id": "mission002",
        "name": "Tartine Bakery",
        "full_address": "600 Guerrero St, San Francisco, CA 94110",
        "latitude": 37.7612,
        "longitude": -122.4244,
        "category_primary": "restaurant",
        "operating_status": "Open"
      }
    ],
    "metadata": {
      "total_results": 342
    }
  }
  ```
</CodeGroup>
