> ## 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.

# Create prospect list

> Create a list of prospects that match your filters



## OpenAPI

````yaml /swagger/v1/openapi.yaml post /api/prospects/create_prospect_list
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/create_prospect_list:
    post:
      tags:
        - Prospect Lists
      summary: Create prospect list
      description: Create a list of prospects that match your filters
      parameters: []
      requestBody:
        content:
          application/json:
            schema:
              type: object
              required:
                - list
                - filters
              properties:
                list:
                  type: object
                  required:
                    - name
                    - max_profiles
                  properties:
                    name:
                      type: string
                      description: Name of the list. e.g. "VP of Sales in San Francisco"
                      example: VP of Sales in San Francisco
                    max_profiles:
                      type: integer
                      description: The number of results to return
                      example: 10
                    enrichment_level:
                      type: string
                      enum:
                        - none
                        - partial
                        - full
                      description: >-
                        >

                        Enrichment level of the list. The default is partial.

                        | Enrichment Level   |
                        Description                          |

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

                        | none   | Will enrich with contact data when you
                        provide a Linkedin profile url or email. But will not
                        find emails or phone numbers |

                        | partial| Will find emails.                     |

                        | full   | Will find emails and phone numbers.   |
                    email_options:
                      description: Types of emails to return.
                      type: object
                      properties:
                        accept_work:
                          type: boolean
                          description: Professional email address, i.e. tim.cooke@apple.com
                        accept_personal:
                          type: boolean
                          description: A personal email address, i.e. tcooke1960@gmail.com
                        accept_generic:
                          type: boolean
                          description: A generic email address, i.e. hello@apple.com
                    skip_duplicates:
                      type: boolean
                      description: >-
                        Skip contacts previously found in other api lists.
                        Contacts will be marked as duplicates and not processed.
                    callback_url:
                      type: string
                      description: >-
                        URL to send the list update to. If not provided, the
                        default webhook URL configured in your account settings
                        will be used.
                  example:
                    name: VP of Sales in San Francisco
                    max_profiles: 10
                    enrichment_level: partial
                    email_options:
                      accept_work: true
                      accept_personal: true
                      accept_generic: true
                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/ListResponse'
        '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"
              },
              "list": {
                "name": "Test List",
                "max_profiles": 10
              }
            });


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


            fetch("https://wiza.co/api/prospects/create_prospect_list",
            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"
              },
              "list": {
                "name": "Test List",
                "max_profiles": 10
              }
            })

            authorization = ("Bearer {api_key}").format(api_key=api_key)

            headers = {
              'Content-Type': 'application/json',
              'Authorization': authorization
            }

            conn.request("POST", "/api/prospects/create_prospect_list", 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/create_prospect_list")

            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"
              },
              "list": {
                "name": "Test List",
                "max_profiles": 10
              }
            })

            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/create_prospect_list'
            --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"
                },
                "list": {
                    "name": "Test List",
                    "max_profiles": 10
                }
            }'
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
    ListResponse:
      type: object
      properties:
        status:
          type: object
          properties:
            code:
              type: integer
              example: 200
            message:
              type: string
              example: 🧙 Wiza is working on it!
        type:
          type: string
          enum:
            - list
          example: list
        data:
          type: object
          properties:
            id:
              type: integer
              example: 15
            name:
              type: string
              example: VP of Sales in San Francisco
            status:
              type: string
              example: queued
            stats:
              type: object
              properties:
                people:
                  type: integer
                  example: 2
                credits:
                  type: object
                  properties:
                    email_credits:
                      type: integer
                      nullable: true
                      example: 1
                    phone_credits:
                      type: integer
                      nullable: true
                      example: 1
                    export_credits:
                      type: integer
                      nullable: true
                      example: 1
                    api_credits:
                      type: object
                      nullable: true
                      properties:
                        email_credits:
                          type: integer
                          example: 2
                        phone_credits:
                          type: integer
                          example: 5
                        scrape_credits:
                          type: integer
                          example: 1
                        total:
                          type: integer
                          example: 8
            finished_at:
              type: string
              format: date-time
              nullable: true
            created_at:
              type: string
              format: date-time
            enrichment_level:
              type: string
              example: partial
            email_options:
              type: object
              properties:
                accept_work:
                  type: boolean
                  example: true
                accept_personal:
                  type: boolean
                  example: true
                accept_generic:
                  type: boolean
                  example: true
            report_type:
              type: string
              example: people
  securitySchemes:
    bearer_auth:
      type: http
      scheme: bearer
      description: >-
        Enter your bearer token (your API key) in the **Authorization** header
        in the format `Bearer {token}`

````