> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wiza.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Prospect search

> Find the number of prospects that match your search filters



## OpenAPI

````yaml /swagger/v1/openapi.yaml post /api/prospects/search
openapi: 3.0.1
info:
  title: Wiza API Documentation
  version: v1
servers:
  - url: https://wiza.co
    variables:
      defaultHost:
        default: wiza.co
security: []
paths:
  /api/prospects/search:
    post:
      tags:
        - Prospect
      summary: Prospect search
      description: Find the number of prospects that match your search filters
      parameters: []
      requestBody:
        content:
          application/json:
            schema:
              type: object
              required:
                - filters
              properties:
                size:
                  type: integer
                  description: The number of results to return. Defaults to 0. Max is 30.
                  example: 10
                filters:
                  type: object
                  properties:
                    first_name:
                      type: array
                      items:
                        type: string
                      description: exact match of first name
                      example:
                        - John
                        - Jane
                    last_name:
                      type: array
                      items:
                        type: string
                      description: exact match of last name
                      example:
                        - Smith
                    job_title:
                      type: array
                      items:
                        type: object
                        properties:
                          v:
                            type: string
                            description: Job title to search
                            example: CEO
                          s:
                            type: string
                            description: whether to include or exclude the job title
                            enum:
                              - i
                              - e
                      description: >-
                        a list of job titles to include/exclude. If you want an
                        exact title match, use double quotes around your search.
                        e.g. '"account manager"'
                    job_title_level:
                      type: array
                      items:
                        type: string
                        enum:
                          - CXO
                          - Director
                          - Entry
                          - Manager
                          - Owner
                          - Partner
                          - Senior
                          - Training
                          - Unpaid
                          - VP
                      description: ''
                    job_role:
                      type: array
                      items:
                        type: string
                        enum:
                          - customer_service
                          - design
                          - education
                          - engineering
                          - finance
                          - health
                          - human_resources
                          - legal
                          - marketing
                          - media
                          - operations
                          - public_relations
                          - real_estate
                          - sales
                          - trades
                      description: ''
                    job_sub_role:
                      type: array
                      items:
                        type: string
                        enum:
                          - accounting
                          - accounts
                          - brand_marketing
                          - broadcasting
                          - business_development
                          - compensation
                          - content_marketing
                          - customer_success
                          - data
                          - dental
                          - devops
                          - doctor
                          - editorial
                          - education_administration
                          - electrical
                          - employee_development
                          - events
                          - fitness
                          - graphic_design
                          - information_technology
                          - instructor
                          - investment
                          - journalism
                          - judicial
                          - lawyer
                          - logistics
                          - marketing_communications
                          - mechanical
                          - media_relations
                          - network
                          - nursing
                          - office_management
                          - paralegal
                          - pipeline
                          - product
                          - product_design
                          - product_marketing
                          - professor
                          - project_engineering
                          - project_management
                          - property_management
                          - quality_assurance
                          - realtor
                          - recruiting
                          - researcher
                          - security
                          - software
                          - support
                          - systems
                          - tax
                          - teacher
                          - therapy
                          - video
                          - web
                          - web_design
                          - wellness
                          - writing
                      description: ''
                    location:
                      type: array
                      items:
                        $ref: '#/components/schemas/Location'
                      example:
                        v: Toronto, Ontario, Canada
                        b: city
                        s: i
                      description: |-
                        >
                        | location type   | format of name input  |
                        |-----------|-----------------------------|
                        | city      | 'city, state, country'      |
                        | state     | 'state, country'            |
                        | country   | 'country'                   |
                    skill:
                      type: array
                      items:
                        type: string
                      description: ''
                    school:
                      type: array
                      items:
                        type: string
                      description: exact match of school name
                    major:
                      type: array
                      items:
                        type: string
                      description: ''
                    linkedin_slug:
                      type: array
                      items:
                        type: string
                      description: >-
                        Can be in the format
                        `https://linkedin.com/in/stephen-hakami-5babb21b0` or
                        `stephen-hakami-5babb21b0`
                      example:
                        - stephen-hakami-5babb21b0
                        - https://linkedin.com/in/stephen-hakami-5babb21b0
                    job_company:
                      type: array
                      items:
                        type: object
                        properties:
                          v:
                            type: string
                            description: Company name
                            example: Wiza
                          s:
                            type: string
                            description: whether to include or exclude the company name
                            enum:
                              - i
                              - e
                      example:
                        - v: Wiza
                          s: i
                      description: a list of company names to include/exclude
                    past_company:
                      type: array
                      items:
                        type: object
                        properties:
                          v:
                            type: string
                            description: Company name
                            example: Wiza
                          s:
                            type: string
                            description: whether to include or exclude the company name
                            enum:
                              - i
                              - e
                      example:
                        - v: Wiza
                          s: i
                      description: >-
                        a list of past company names to include/exclude. Note
                        that this will return people who used to work at the
                        company AND people who currently work at the company. If
                        you want to exclude people who currently work at the
                        company, use the `job_company` filter with the exclude
                        flag.
                    company_location:
                      type: array
                      items:
                        $ref: '#/components/schemas/Location'
                      example:
                        - v: Toronto, Ontario, Canada
                          b: city
                          s: e
                      description: |-
                        >
                        | location type   | format of name input  |
                        |-----------|-----------------------------|
                        | city      | 'city, state, country'      |
                        | state     | 'state, country'            |
                        | country   | 'country'                   |
                    company_industry:
                      type: array
                      items:
                        type: object
                        properties:
                          v:
                            type: string
                            description: >-
                              Industry name. Must be one of the valid industry
                              values.
                            example: building materials
                          s:
                            type: string
                            description: >-
                              Include or exclude filter. Use 'i' to include this
                              industry, 'e' to exclude it. If not specified,
                              defaults to include.
                            enum:
                              - i
                              - e
                      example:
                        - v: building materials
                        - v: capital markets
                          s: e
                      description: >-
                        a list of company industries to include/exclude.


                        **How it works:**

                        - Use `v` to specify the industry name

                        - Use `s` to control filtering: 'i' = include, 'e' =
                        exclude

                        - If `s` is not specified, the industry will be included
                        by default

                        - You can mix include and exclude filters in the same
                        request


                        **Examples:**

                        - Include only: `[{v: "building materials"}]` or `[{v:
                        "building materials", s: "i"}]`

                        - Exclude only: `[{v: "capital markets", s: "e"}]`

                        - Mixed: `[{v: "building materials"}, {v: "capital
                        markets", s: "e"}]`


                        Valid industry values:


                        | Value |

                        |-------|

                        | accounting |

                        | airlines/aviation |

                        | alternative dispute resolution |

                        | alternative medicine |

                        | animation |

                        | apparel & fashion |

                        | architecture & planning |

                        | arts and crafts |

                        | automotive |

                        | aviation & aerospace |

                        | banking |

                        | biotechnology |

                        | broadcast media |

                        | building materials |

                        | business supplies and equipment |

                        | capital markets |

                        | chemicals |

                        | civic & social organization |

                        | civil engineering |

                        | commercial real estate |

                        | computer & network security |

                        | computer games |

                        | computer hardware |

                        | computer networking |

                        | computer software |

                        | construction |

                        | consumer electronics |

                        | consumer goods |

                        | consumer services |

                        | cosmetics |

                        | dairy |

                        | defense & space |

                        | design |

                        | e-learning |

                        | education management |

                        | electrical/electronic manufacturing |

                        | entertainment |

                        | environmental services |

                        | events services |

                        | executive office |

                        | facilities services |

                        | farming |

                        | financial services |

                        | fine art |

                        | fishery |

                        | food & beverages |

                        | food production |

                        | fund-raising |

                        | furniture |

                        | gambling & casinos |

                        | government administration |

                        | government relations |

                        | graphic design |

                        | health, wellness and fitness |

                        | higher education |

                        | hospital & health care |

                        | hospitality |

                        | human resources |

                        | import and export |

                        | individual & family services |

                        | industrial automation |

                        | information services |

                        | information technology and services |

                        | insurance |

                        | international affairs |

                        | international trade and development |

                        | internet |

                        | investment banking |

                        | investment management |

                        | judiciary |

                        | law enforcement |

                        | law practice |

                        | legal services |

                        | legislative office |

                        | libraries |

                        | logistics and supply chain |

                        | luxury goods & jewelry |

                        | machinery |

                        | management consulting |

                        | maritime |

                        | market research |

                        | marketing and advertising |

                        | mechanical or industrial engineering |

                        | media production |

                        | medical devices |

                        | medical practice |

                        | mental health care |

                        | military |

                        | mining & metals |

                        | motion pictures and film |

                        | museums and institutions |

                        | music |

                        | nanotechnology |

                        | newspapers |

                        | non-profit organization management |

                        | oil & energy |

                        | online media |

                        | outsourcing/offshoring |

                        | package/freight delivery |

                        | packaging and containers |

                        | paper & forest products |

                        | performing arts |

                        | pharmaceuticals |

                        | philanthropy |

                        | photography |

                        | plastics |

                        | political organization |

                        | primary/secondary education |

                        | printing |

                        | professional training & coaching |

                        | program development |

                        | public policy |

                        | public relations and communications |

                        | public safety |

                        | publishing |

                        | railroad manufacture |

                        | ranching |

                        | real estate |

                        | recreational facilities and services |

                        | religious institutions |

                        | renewables & environment |

                        | research |

                        | restaurants |

                        | retail |

                        | security and investigations |

                        | semiconductors |

                        | shipbuilding |

                        | sporting goods |

                        | sports |

                        | staffing and recruiting |

                        | supermarkets |

                        | telecommunications |

                        | textiles |

                        | think tanks |

                        | tobacco |

                        | translation and localization |

                        | transportation/trucking/railroad |

                        | utilities |

                        | venture capital & private equity |

                        | veterinary |

                        | warehousing |

                        | wholesale |

                        | wine and spirits |

                        | wireless |

                        | writing and editing |
                    company_size:
                      type: array
                      items:
                        type: string
                        enum:
                          - 1-10
                          - 11-50
                          - 51-200
                          - 201-500
                          - 501-1000
                          - 1001-5000
                          - 5001-10000
                          - 10001+
                      description: Company Headcount
                    company_annual_growth:
                      type: string
                      enum:
                        - 0-5%
                        - 5-10%
                        - 10-20%
                        - 20-50%
                        - 50-100%
                        - 100%+
                      description: Company Headcount Annual Growth
                    department_size:
                      type: array
                      items:
                        type: string
                      description: >-
                        >

                        Department Headcount, the format is
                        `{department_name}:{min_headcount}-{max_headcount}` e.g.
                        `sales:10-50`


                        For less than or greater than, use `min_headcount-` or
                        `-max_headcount` e.g. `sales:10-` or `sales:-50`


                        Available department names:

                        | department_name |

                        |-----------------|

                        | legal |

                        | media |

                        | sales |

                        | design |

                        | health |

                        | trades |

                        | finance |

                        | education |

                        | marketing |

                        | operations |

                        | engineering |

                        | real_estate |

                        | human_resources |

                        | customer_service |

                        | public_relations |
                      example:
                        - sales:10-50
                    revenue:
                      type: array
                      items:
                        type: string
                        enum:
                          - $0-$1M
                          - $1M-$10M
                          - $10M-$25M
                          - $25M-$50M
                          - $50M-$100M
                          - $100M-$250M
                          - $250M-$500M
                          - $500M-$1B
                          - $1B-$10B
                          - $10B+
                      description: Company Revenue
                    funding_date:
                      type: object
                      properties:
                        t:
                          type: string
                          enum:
                            - last
                            - any
                          description: >-
                            Whether the funding date is the last round's funding
                            date or any funding date
                        v:
                          type: string
                          enum:
                            - 60d
                            - 90d
                            - 180d
                            - 270d
                            - 1y
                          description: Funding Date Range
                      description: Company Funding Date
                    last_funding_min:
                      type: string
                      enum:
                        - $500K
                        - $1M
                        - $5M
                        - $10M
                        - $25M
                        - $50M
                        - $100M
                        - $250M
                        - $500M
                        - $1B
                      description: Company Last Funding Amount Min
                    last_funding_max:
                      type: string
                      enum:
                        - $500K
                        - $1M
                        - $5M
                        - $10M
                        - $25M
                        - $50M
                        - $100M
                        - $250M
                        - $500M
                        - $1B
                      description: Company Last Funding Amount Max
                    funding_min:
                      type: string
                      enum:
                        - $500K
                        - $1M
                        - $5M
                        - $10M
                        - $25M
                        - $50M
                        - $100M
                        - $250M
                        - $500M
                        - $1B
                      description: Company Total Funding Amount Min
                    funding_max:
                      type: string
                      enum:
                        - $500K
                        - $1M
                        - $5M
                        - $10M
                        - $25M
                        - $50M
                        - $100M
                        - $250M
                        - $500M
                        - $1B
                      description: Company Total Funding Amount Max
                    funding_stage:
                      type: object
                      properties:
                        t:
                          type: string
                          enum:
                            - last
                            - any
                          description: >-
                            Whether the funding stage is the last round's
                            funding stage or any funding stage
                        v:
                          type: array
                          items:
                            type: string
                            enum:
                              - pre_seed
                              - seed
                              - series_a
                              - series_b
                              - series_c
                              - series_d
                              - series_e-j
                              - other
                          description: Funding Stage
                      description: Company Funding Stage
                    funding_type:
                      type: object
                      properties:
                        t:
                          type: string
                          enum:
                            - last
                            - any
                          description: >-
                            Whether the funding type is the last round's funding
                            type or any funding type
                        v:
                          type: array
                          items:
                            type: string
                            enum:
                              - angel
                              - venture
                              - grant
                              - debt_financing
                              - private_equity
                              - crowdfunding
                              - other
                          description: Funding Type
                      description: Company Funding Type
                    company_type:
                      type: array
                      items:
                        type: string
                        enum:
                          - private
                          - public
                          - educational
                          - government
                          - nonprofit
                          - public_subsidiary
                      description: Company Type
                    company_summary:
                      type: array
                      items:
                        type: object
                        properties:
                          v:
                            type: string
                            description: Words to search in the company summary
                            example: cutting-edge
                          s:
                            type: string
                            description: whether to include or exclude the words
                            enum:
                              - i
                              - e
                      description: >-
                        a list of words to include/exclude in the company
                        summary
                    year_founded_start:
                      type: string
                      example: '2020'
                      description: Company Year Founded Start
                    year_founded_end:
                      type: string
                      example: '2024'
                      description: Company Year Founded End
      responses:
        '200':
          description: successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProspectSearchResponse'
        '400':
          description: Invalid request
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: object
                    properties:
                      code:
                        type: integer
                        example: 400
                      message:
                        type: string
                        example: ''
                        description: ''
        '401':
          description: Unauthorized
      security:
        - bearer_auth: []
      x-codeSamples:
        - lang: Javascript
          source: |
            const apiKey = "your api key here" // update with your api_key

            const myHeaders = new Headers();
            myHeaders.append("Content-Type", "application/json");
            myHeaders.append("Authorization", `Bearer ${apiKey}`);

            const raw = JSON.stringify({
              "filters": {
                "job_title": [
                  {
                    "v": "CEO",
                    "s": "i"
                  }
                ],
                "job_title_level": [
                  "CXO"
                ],
                "job_role": [
                  "finance"
                ],
                "location": [
                  {
                    "v": "Toronto, Ontario, Canada",
                    "b": "city",
                    "s": "i"
                  }
                ],
                "company_location": [
                  {
                    "v": "Ontario, Canada",
                    "b": "state",
                    "s": "i"
                  }
                ],
                "company_size": [
                  "1-10",
                  "11-50"
                ],
                "company_industry": [
                  "financial services"
                ],
                "year_founded_start": "2010",
                "year_founded_end": "2024"
              }
            });

            const requestOptions = {
              method: "POST",
              headers: myHeaders,
              body: raw,
              redirect: "follow"
            };

            fetch("https://wiza.co/api/prospects/search", requestOptions)
              .then((response) => response.text())
              .then((result) => console.log(result))
              .catch((error) => console.error(error));
        - lang: Python
          source: |
            import http.client
            import json

            api_key = "your api key here" # update with your api_key

            conn = http.client.HTTPSConnection("wiza.co")
            payload = json.dumps({
              "filters": {
                "job_title": [
                  {
                    "v": "CEO",
                    "s": "i"
                  }
                ],
                "job_title_level": [
                  "CXO"
                ],
                "job_role": [
                  "finance"
                ],
                "location": [
                  {
                    "v": "Toronto, Ontario, Canada",
                    "b": "city",
                    "s": "i"
                  }
                ],
                "company_location": [
                  {
                    "v": "Ontario, Canada",
                    "b": "state",
                    "s": "i"
                  }
                ],
                "company_size": [
                  "1-10",
                  "11-50"
                ],
                "company_industry": [
                  "financial services"
                ],
                "year_founded_start": "2010",
                "year_founded_end": "2024"
              }
            })
            authorization = ("Bearer {api_key}").format(api_key=api_key)
            headers = {
              'Content-Type': 'application/json',
              'Authorization': authorization
            }
            conn.request("POST", "/api/prospects/search", payload, headers)
            res = conn.getresponse()
            data = res.read()
            print(data.decode("utf-8"))
        - lang: Ruby
          source: |+
            require "uri"
            require "json"
            require "net/http"

            api_key = "your api key here" # update with your api_key

            url = URI("https://wiza.co/api/prospects/search")

            https = Net::HTTP.new(url.host, url.port);
            https.use_ssl = true
            request = Net::HTTP::Post.new(url)
            request["Content-Type"] = "application/json"
            request["Authorization"] = "Bearer #{api_key}"
            request.body = JSON.dump({
              "filters": {
                "job_title": [
                  {
                    "v": "CEO",
                    "s": "i"
                  }
                ],
                "job_title_level": [
                  "CXO"
                ],
                "job_role": [
                  "finance"
                ],
                "location": [
                  {
                    "v": "Toronto, Ontario, Canada",
                    "b": "city",
                    "s": "i"
                  }
                ],
                "company_location": [
                  {
                    "v": "Ontario, Canada",
                    "b": "state",
                    "s": "i"
                  }
                ],
                "company_size": [
                  "1-10",
                  "11-50"
                ],
                "company_industry": [
                  "financial services"
                ],
                "year_founded_start": "2010",
                "year_founded_end": "2024"
              }
            })

            response = https.request(request)
            puts response.read_body

        - lang: Curl
          source: >
            api_key="your api key here" # update with your api_key


            curl --location 'https://wiza.co/api/prospects/search' --header
            'Content-Type: application/json' --header "Authorization: Bearer
            ${api_key}" --data '{   
              "filters": {
                "job_title": [
                  {
                    "v": "CEO",
                    "s": "i"
                  }
                ],
                "job_title_level": [
                  "CXO"
                ],
                "job_role": [
                  "finance"
                ],
                "location": [
                  {
                    "v": "Toronto, Ontario, Canada",
                    "b": "city",
                    "s": "i"
                  }
                ],
                "company_location": [
                  {
                    "v": "Ontario, Canada",
                    "b": "state",
                    "s": "i"
                  }
                ],
                "company_size": ["1-10","11-50"],
                "company_industry": ["financial services"],
                "year_founded_start": "2010",
                "year_founded_end": "2024"
              }
            }'
components:
  schemas:
    Location:
      type: object
      properties:
        v:
          type: string
          description: name of the location
          example: Toronto, Ontario, Canada
        b:
          type: string
          description: type of location
          enum:
            - city
            - state
            - country
        s:
          type: string
          description: whether to include or exclude the location
          enum:
            - i
            - e
    ProspectSearchResponse:
      type: object
      properties:
        status:
          type: object
          properties:
            code:
              type: integer
              example: 200
            message:
              type: string
              example: ''
        data:
          type: object
          properties:
            total:
              type: integer
              example: 15
            profiles:
              type: array
              items:
                type: object
                properties:
                  full_name:
                    type: string
                    example: Stephen Hakami
                  linkedin_url:
                    type: string
                    example: linkedin.com/in/stephen-hakami-5babb21b0
                  industry:
                    type: string
                    example: Computer Software
                  job_title:
                    type: string
                    example: Founder, Chief Executive Officer
                  job_title_role:
                    type: string
                    nullable: true
                    example: null
                  job_title_sub_role:
                    type: string
                    nullable: true
                    example: null
                  job_company_name:
                    type: string
                    example: Wiza
                  job_company_website:
                    type: string
                    example: wiza.co
                  location_name:
                    type: string
                    example: Toronto, Ontario, Canada
  securitySchemes:
    bearer_auth:
      type: http
      scheme: bearer
      description: >-
        Enter your bearer token (your API key) in the **Authorization** header
        in the format `Bearer {token}`

````